---

point2d.H

Go to the documentation of this file.

/*
 * Copyright 2000, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef AMOD_MATH_LIB_INC_POINT2d_H
#define AMOD_MATH_LIB_INC_POINT2d_H

#include <math.h>
#include "std/config.H"
#include "vector2d.H"


template <class P, class V>
class _point2d {
protected:
    Greal _x, _y;

public:

    _point2d()                     : _x(0),    _y(0)    {}
    _point2d(Greal xx, Greal yy) : _x(xx),   _y(yy)   {}

    const Greal *data()               const { return &_x; }
    P        operator  %(const P &p)   const { return P(_x+p[0],_y+p[1]);}
    P        operator  +(const V &v)   const { return P(_x+v[0],_y+v[1]);}
    V        operator  -(const P &p)   const { return V(_x-p[0],_y-p[1]);}
    P        operator  -(const V &v)   const { return P(_x-v[0],_y-v[1]);}
    P        operator  -()             const { return P(-_x,   -_y);     }

    P        operator  *(Greal    s)  const { return P(_x*s, _y*s); }
    P        operator  /(Greal    s)  const { return P(_x/s, _y/s); }
    
    Greal   operator [](int index)    const { return (&_x)[index];     }
    Greal&  operator [](int index)          { return (&_x)[index];     }

    Greal   length     ()             const { return sqrt(_x*_x+_y*_y); }
    Greal   lengthSqrd ()             const { return _x*_x+_y*_y;       }

    Greal   distSqrd   (const P &p)   const { return (_x-p._x) * (_x-p._x) + 
                                                      (_y-p._y) * (_y-p._y);  }
    Greal   dist       (const P &p)   const { return sqrt(distSqrd(p)); }

    bool     isEqual    (const P &p, Greal epsSqrd = epsAbsSqrdMath()) const 
                                             { return distSqrd(p) <= epsSqrd; }

    void     operator +=(const P &p)         { _x += p[0]; _y += p[1];     }
    void     operator +=(const V &v)         { _x += v[0]; _y += v[1];     }
    void     operator -=(const P &p)         { _x -= p[0]; _y -= p[1];     }
    void     operator -=(const V &v)         { _x -= v[0]; _y -= v[1];     }
    void     operator *=(Greal scalar)      { _x *= scalar; _y *= scalar; }
    void     operator /=(Greal scalar)      { _x /= scalar; _y /= scalar; }

    bool     operator ==(const P &p)   const { return _x == p._x && _y == p._y;}
    bool     operator !=(const P &p)   const { return _x != p._x || _y != p._y;}

}; // class _point2d


/* ---------- inlined global functions using _point2d template ------ */


template <class P, class V>
inline ostream &
operator <<(ostream &os, const _point2d<P,V> &p) 
{ 
   return os << "< " << p[0] << " " << p[1] << " >"; 
}

template <class P, class V>
inline istream &
operator>>(istream &is, _point2d<P,V> &p) 
{ 
   char dummy;
   return is >> dummy >> p[0] >> p[1] >> dummy;
}

template <class P, class V>
inline Greal det(const _point2d<P,V> &a, const _point2d<P,V> &b) {
                   return (a[0] * b[1] - a[1] * b[0]); }


#define TPLIST _point2d_list<L,P,V>

template <class L,class P,class V>
class _point2d_list : public ARRAY<P> {
   protected :
    ARRAY<Greal>    _partial_length;
    Greal           _length;

   public :
    _point2d_list(int m=16)         :ARRAY<P>(m), _partial_length(0) {_length=0;}
    _point2d_list(const ARRAY<P> &p):ARRAY<P>(p), _partial_length(0) {_length=0;}

    // Intersection
    int     contains(const TPLIST &list)                          const;
    int     contains(const P &p)                                  const;
    bool    ray_intersect(const P &p,const V &d,P &hit,int loop=0)const;
    P       ray_intersect(const P &p,const V &d,int k0,int k1)    const;

    // Distance computations
    Greal  dist_to_seg     (const P &p, int k)                   const;
    Greal  avg_dist_to_seg (const P &p, int k)                   const;
    int     nearest_point   (const P &p)                          const;
    P       average ()                                            const;
    void    closest (const P &p, P &, Greal &, int &)            const;
    Greal  closest (const P &p, P &, int &)                      const;
    P       closest (const P &p)                                  const;

    // Parameterization / Length 
    void    update_length      ();
    Greal  partial_length     (int i) const {
       return (i>=_partial_length.num())? 0 : _partial_length[i]; }
    Greal  length             ()      const { return _length; }
    Greal  segment_length     (int i) const {
       return (_array[i+1]-_array[i]).length(); }

    V       get_tangent(Greal s) const;
    
    // Interpolation
    P       interpolate        (Greal s, V *tan=0,
                                int *segp=0, Greal *tp=0)      const;
    void    interpolate_length (Greal s, int &seg, Greal &t ) const;
    Greal  invert             (const P &p)                     const;
    Greal  invert             (const P &p, int seg)            const;

    // Editing
    L      *clone_piece     (int k1, int k2) const;
    void    append          (TPLIST *poly);
    void    prepend         (TPLIST *poly);
   
};

#ifdef GLUE_NEEDS_TEMPLATES_IN_H_FILE
#include "point2d.C"
#endif
#endif // AMOD_MATH_LIB_INC_POINT2d_H

/* end of file point2d.H */

---