---

points.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 POINTS_H
#define POINTS_H

#define GLUE_MLIB

class Wquat;
class Wtransf;
class Wplane;
class Wline;
class Wpt;
class Wvec;
class ROOMpt;
class ROOMvec;
class XYline;
class XYvec;
class XYpt;
class NDCvec;
class NDCpt;
class NDCZvec;
class NDCZpt;
class NDCZpt_list;
class VEXEL;
class PIXEL;
typedef const class Wquat cWquat;
typedef const class Wpt_list cWpt_list;
typedef const class Wplane cWplane;
typedef const class Wtransf cWtransf;
typedef const class Wline cWline;
typedef const class Wvec cWvec;
typedef const class Wpt cWpt;
typedef const class ROOMvec cROOMvec;
typedef const class ROOMpt cROOMpt;
typedef const class XYpt cXYpt;
typedef const class XYvec cXYvec;
typedef const class XYline cXYline;
typedef const class XYpt_list cXYpt_list;
typedef const class NDCvec cNDCvec;
typedef const class NDCpt cNDCpt;
typedef const class NDCZvec cNDCZvec;
typedef const class NDCZpt cNDCZpt;
typedef const class NDCZpt_list cNDCZpt_list;
typedef const class VEXEL cVEXEL;
typedef const class PIXEL cPIXEL;

#include "std/strings.H"

#include "mlib/point2d.H"
#include "mlib/point3d.H"
#include "mlib/plane.H"
#include "mlib/transf3d.H"
#include "mlib/quat.H"
#include "mlib/nearest_pt.H"

//---------------------------------------------------
//   World Coordinates
//---------------------------------------------------
class DllImpExp Wvec : public _vec3d<Wvec> {
   public :
    static cWvec X;
    static cWvec Y;
    static cWvec Z;
    Wvec()        { }
    Wvec(cXYpt &);
    Wvec(Greal x, Greal y, Greal z):_vec3d<Wvec>(x,y,z) { }
    Wvec(cWpt &, cVEXEL &);
    Wvec(cROOMvec &);
};
#ifdef GLUE_NEEDS_DOUBLE_STAR_EXPLICIT
// Should be able to define this once for _vec3d, but that doesn't work
// (then again, we have to do this because of template problems in the first
// place)
inline Wvec operator *(Greal s, const Wvec& p) { return p * s;}
#endif

class DllImpExp Wpt : public _point3d<Wpt, Wvec> {
   public :
           Wpt() { }
           Wpt(Greal x, Greal y, Greal z):_point3d<Wpt,Wvec>(x,y,z) { }
           Wpt(cXYpt &);
           Wpt(cNDCZpt &);
           Wpt(cXYpt &, Greal d);
           Wpt(cXYpt &, cWpt &);
           Wpt(cROOMpt &);
    inline Wpt(cWtransf &);
    inline Wpt(cWline &, cWline &);
    inline Wpt(cWline &, cWpt   &);
    inline Wpt(cWplane&, cWline &);
};
#ifdef GLUE_NEEDS_DOUBLE_STAR_EXPLICIT
inline Wpt operator *(Greal s, const Wpt& p) { return p * s;}
#endif

class Wline : public _line<Wline, Wpt, Wvec> 
{
   public:
     Wline() { }
     Wline(cWpt &p,  cWvec &v) : _line<Wline,Wpt,Wvec>(p,v)  {}
     Wline(cWpt &p1, cWpt  &p2): _line<Wline,Wpt,Wvec>(p1,p2) {}
     Wline(cXYpt&x)            : _line<Wline,Wpt,Wvec>(Wpt(x),Wvec(x)) {}
};

#define TRANSF3D _transf3d<Wtransf,Wpt,Wvec,Wline,Wquat>
class Wtransf : public TRANSF3D
{
   public:
    Wtransf()   { }
    Wtransf(cWpt   &  origin, 
            cWvec  &    xDir, 
            cWvec  &    yDir, 
            cWvec  &    zDir) : TRANSF3D(origin,xDir,yDir,zDir) { }
    Wtransf(cWvec  &    col0, 
            cWvec  &    col1, 
            cWvec  &    col2) : TRANSF3D(col0,col1,col2) { }
    Wtransf(cWpt   &  origin, 
            cWvec  &    xDir, 
            cWvec  &    yDir) : TRANSF3D(origin,xDir,yDir) { }
    Wtransf(cWline &  axis)   : TRANSF3D(axis) { }
    Wtransf(cWpt   &  origin) : TRANSF3D(origin) { }
};
#undef TRANSF3D

#define DPLANE _plane<Wplane,Wpt,Wvec,Wline>
class Wplane : public DPLANE {
   public :
    Wplane()                     { }
    Wplane(cWvec  &n, Greal d)             : DPLANE(n,d) { }
    Wplane(cWpt&n, cWvec&v)                 : DPLANE(n,v) { }
    Wplane(cWpt&n, cWpt&p1, cWpt&p2)        : DPLANE(n,p1,p2) { }
    Wplane(cWpt&p, cWvec&v1, cWvec&v2)      : DPLANE(p,v1,v2) { }
    Wplane(cWpt plg[], int n)               : DPLANE(plg,n) { }
    Wplane(cWpt plg[], int n, cWvec& normal): DPLANE(plg,n,normal) { }
};
#undef DPLANE

inline Wpt::Wpt(cWtransf &t)           { (*this) = t.origin(); }
inline Wpt::Wpt(cWline  &a, cWline &b) { (*this) = a.intersect(b); }
inline Wpt::Wpt(cWline  &a, cWpt   &b) { (*this) = a.project(b); }
inline Wpt::Wpt(cWplane &a, cWline &b) { (*this) = a.intersect(b); }

class Wpt_list : public _point3d_list<Wpt_list,Wtransf,Wpt, Wvec>
{
  public:
   Wpt_list(int max=0):_point3d_list<Wpt_list,Wtransf,Wpt,Wvec>(max) { }
   Wpt_list(const _point3d_list<Wpt_list,Wtransf,Wpt,Wvec> &p)
                       :_point3d_list<Wpt_list,Wtransf,Wpt,Wvec>(p)   { }
   Wpt_list(const _point3d_list<Wpt_list,Wtransf,Wpt,Wvec> &p, cWtransf &t)
                       :_point3d_list<Wpt_list,Wtransf,Wpt,Wvec>(p,t) { }
};

inline Wpt_list 
operator *(cWtransf &x, cWpt_list &pts) {
   Wpt_list res;
   for (int i = 0; i < pts.num(); i++)
      res += x * pts[i];
   return res;
}

#define QUAT _quat<Wquat, Wtransf, Wpt, Wvec, Wline>
class Wquat : public QUAT
{
public:
   Wquat()                      {}
   Wquat(cWvec& v, Greal w)    : QUAT(v,w) {}
   Wquat(Greal s)              : QUAT(Wvec(),s) {}
   Wquat(cWtransf& t)           : QUAT(t) {}
   Wquat(cWvec& v1, cWvec& v2)  : QUAT(v1,v2) {}
};
#undef QUAT
   
//---------------------------------------------------
//   ROOM Coordinates
// Physical coordinate mapping of the platform
// coordinates in meters.
//---------------------------------------------------
class DllImpExp ROOMvec : public _vec3d<ROOMvec> {
   public :
    static cROOMvec X;
    static cROOMvec Y;
    static cROOMvec Z;
    ROOMvec()        { }
    ROOMvec(cWvec &);
    ROOMvec(Greal x, Greal y, Greal z):_vec3d<ROOMvec>(x,y,z) { }
};
#ifdef GLUE_NEEDS_DOUBLE_STAR_EXPLICIT
inline ROOMvec operator *(Greal s, const ROOMvec& p) { return p * s;}
#endif
class DllImpExp ROOMpt : public _point3d<ROOMpt, ROOMvec> {
   public :
    ROOMpt() { }
    ROOMpt(Greal x, Greal y, Greal z):_point3d<ROOMpt,ROOMvec>(x,y,z) { }
    ROOMpt(cWpt &);
};


//---------------------------------------------------
//   XY coordinates : -1 to 1 normalized coordinates
//---------------------------------------------------
class XYvec : public _vec2d<XYvec> {
   public :
    XYvec() { }
    XYvec(Greal x, Greal y):_vec2d<XYvec>(x,y) { }
    DllImpExp XYvec(cNDCvec &);
    DllImpExp XYvec(cVEXEL &);
};
#ifdef GLUE_NEEDS_DOUBLE_STAR_EXPLICIT
inline XYvec operator *(Greal s, const XYvec& p) { return p * s;}
#endif
class DllImpExp XYpt : public _point2d<XYpt, XYvec> {
   public :
          XYpt() { }
          XYpt(Greal x, Greal y):_point2d<XYpt,XYvec>(x,y) { }
          XYpt(cNDCpt &);
          XYpt(cPIXEL &);
          XYpt(cWpt   &);
   inline XYpt(cXYline &, cXYline &);
   inline XYpt(cXYline &, cXYpt   &);
};
#ifdef GLUE_NEEDS_DOUBLE_STAR_EXPLICIT
inline XYpt operator *(Greal s, const XYpt& p) { return p * s;}
#endif
class XYline : public _line<XYline, XYpt, XYvec> 
{
   public:
     XYline() { }
     XYline(cXYpt &p,  cXYvec &v) : _line<XYline,XYpt,XYvec>(p,v)  {}
     XYline(cXYpt &p1, cXYpt  &p2): _line<XYline,XYpt,XYvec>(p1,p2) {}
};
class XYpt_list : public _point2d_list<XYpt_list,XYpt,XYvec> {
   public :
    XYpt_list(int m=0):_point2d_list<XYpt_list,XYpt,XYvec>(m) { }
    XYpt_list(const _point2d_list<XYpt_list,XYpt,XYvec> &p)
                       :_point2d_list<XYpt_list,XYpt,XYvec>(p) { }
};

inline XYpt::XYpt(cXYline &a, cXYline &b) {(*this) = a.intersect(b);}
inline XYpt::XYpt(cXYline &a, cXYpt   &b) {(*this) = a.project(b);}

//------------------------------------------------------
//   NDCZ coordinates : 3D normalized aspect coordinates
//------------------------------------------------------
class DllImpExp NDCZvec : public _vec3d<NDCZvec> {
   public :
    NDCZvec() { }
    NDCZvec(Greal x, Greal y, Greal z):_vec3d<NDCZvec>(x,y,z) { }
    NDCZvec(cNDCvec &);
    NDCZvec(cXYvec &);
    NDCZvec(cWvec&v, cWtransf& obj_to_ndc_der);
    NDCZvec(cVEXEL &);   

    NDCZvec perpendicular() const { return NDCZvec(-_y, _x, 0); }
    Greal  planar_length() const { return sqrt(_x*_x+_y*_y); }
};
#ifdef GLUE_NEEDS_DOUBLE_STAR_EXPLICIT
inline NDCZvec operator *(Greal s, const NDCZvec& p) { return p * s;}
#endif

class DllImpExp NDCZpt : public _point3d<NDCZpt, NDCZvec> {
   public :
     NDCZpt() { }
     NDCZpt(Greal x, Greal y, Greal z):_point3d<NDCZpt,NDCZvec>(x,y,z) { }
     NDCZpt(cWpt &w);
     NDCZpt(cWpt &w, cWtransf& PM);
     NDCZpt(cXYpt &);
     NDCZpt(cNDCpt &);
     NDCZpt(cPIXEL &);
     Greal planar_length(cNDCZpt& p) const {
        Greal dx = _x - p._x, dy = _y - p._y;
        return sqrt(dx*dx + dy*dy);
     }
};

class DllImpExp NDCZpt_list : public ARRAY<NDCZpt> {
 protected:
   ARRAY<Greal>    _partial_length;

 public :
   NDCZpt_list(int max=0)             :ARRAY<NDCZpt>(max) { }
   NDCZpt_list(const ARRAY<NDCZpt> &p) :ARRAY<NDCZpt>(p) { }

   // Parameterization / Lengths
   NDCZpt       interpolate(Greal s, NDCZvec *tan=0, 
                            int*segp=0, Greal*tp=0) const;
   void         interpolate_length(Greal s, int &seg, Greal &t) const;

   void   update_length      () { Greal len = 0;
                                  _partial_length.clear();
                                  if (_num > 0)
                                     _partial_length.realloc(_num);
                                  _partial_length += 0;
                                  for ( int i=1; i< _num; i++ ) {
                                     len += segment_length(i-1);
                                     _partial_length += len;
                                  }
                               }
   Greal partial_length     (int i) const { return i>=_partial_length.num() ? 
                                                   0 : _partial_length[i]; }
   Greal length             ()      const { return _partial_length.last(); }
   NDCZvec segment           (int i) const { return _array[i+1]-_array[i];}
   Greal segment_length     (int i) const { return segment(i).length(); }

   // misc
   NDCZvec  tan(int i)      const;
   NDCZvec  normal() const {
               NDCZvec ret(0, 1, 0);
               if (num() > 2) {
                  const int delta = num() / 3;
                  const NDCZpt a = _array[0];
                  const NDCZpt b = _array[delta];
                  const NDCZpt c = _array[2 * delta];
                  const NDCZpt d = _array[(3 * delta) % num()];
                  ret = NDCZvec((c[1]-a[1])*(d[2]-b[2]) + (c[2]-a[2])*(b[1]-d[1]),
                          (c[2]-a[2])*(d[0]-b[0]) + (c[0]-a[0])*(b[2]-d[2]),
                          (c[0]-a[0])*(d[1]-b[1]) + (c[1]-a[1])*(b[0]-d[0]));
               }
               return ret;
          }

   NDCZpt   average () const { NDCZpt sum; 
                               for(int i=0;i<num();i++) sum=sum%(*this)[i];
                               return sum/(num() ? num():1); 
                             }
};

DllImpExp NDCZvec normal_to_ndcz(cWpt& p, cWvec& world_normal);

//---------------------------------------------------
//   NDC coordinates : normalized aspect coordinates
//---------------------------------------------------
class DllImpExp NDCvec : public _vec2d<NDCvec> {
   public :
    NDCvec() { }
    NDCvec(Greal x, Greal y):_vec2d<NDCvec>(x,y) { }
    NDCvec(cXYvec &);
    NDCvec(cVEXEL &);
};
class DllImpExp NDCpt : public _point2d<NDCpt, NDCvec> {
   public :
     NDCpt() { }
     NDCpt(Greal x, Greal y):_point2d<NDCpt,NDCvec>(x,y) { }
     NDCpt(cNDCZpt& n):_point2d<NDCpt,NDCvec>(n[0],n[1]) { }
     NDCpt(cWpt &w);
     NDCpt(cXYpt &);
};

//---------------------------------------------------
//   PIXEL coordinates
//
//      corresponds to GL-style pixels coords:
//      lower left corner is (0,0)
//      upper right is (width-1, height-1)
//---------------------------------------------------
class DllImpExp VEXEL : public _vec2d<VEXEL> {
 public :
   VEXEL() { }
   VEXEL(Greal x, Greal y):_vec2d<VEXEL>(x,y) { }
   VEXEL(cXYvec &);
   VEXEL(cNDCvec &);
   VEXEL(cWpt &, cWvec &);
};
#ifdef GLUE_NEEDS_DOUBLE_STAR_EXPLICIT
inline VEXEL operator *(Greal s, const VEXEL& p) { return p * s;}
#endif

class DllImpExp PIXEL : public _point2d<PIXEL, VEXEL> {
 public :
   PIXEL() { }
   PIXEL(Greal x, Greal y):_point2d<PIXEL,VEXEL>(x,y) { }
   PIXEL(cXYpt &);
   // XXX - workaround for gcc 2.97
   PIXEL(cWpt &w) { cXYpt xy(w); cPIXEL pix = xy; *this = pix; }
};

class PIXELline : public _line<PIXELline, PIXEL, VEXEL> {
 public:
   PIXELline() : _line<PIXELline, PIXEL, VEXEL> () { }
   PIXELline(cPIXEL &p, cVEXEL &v) :
      _line<PIXELline, PIXEL, VEXEL>(p,v)          { }
   PIXELline(cPIXEL &p1, cPIXEL &p2) :
      _line<PIXELline, PIXEL, VEXEL>(p1,p2)        { }
};

class PIXEL_list : public _point2d_list<PIXEL_list,PIXEL,VEXEL> {
 public:
   PIXEL_list(int n=0) : _point2d_list<PIXEL_list,PIXEL,VEXEL>(n) { }
   PIXEL_list(const _point2d_list<PIXEL_list,PIXEL,VEXEL> &list) :
      _point2d_list<PIXEL_list,PIXEL,VEXEL>(list)                  { }
   PIXEL_list(const XYpt_list &list) :
      _point2d_list<PIXEL_list,PIXEL,VEXEL>(list.num())            {
      for(int i=0; i<list.num(); i++ ) {
         // must use operator+=() instead of (*this) += so it will 
         // compile under windows
         operator+=(PIXEL(list[i]));
      }
   }
};


extern DllImpExp cWtransf &Identity;
extern DllImpExp cWpt     &Origin;

inline double
world_length(cWpt& p, double r)
{
   // given point p in world space and pixel length r,
   // return the world space length of a segment passing
   // through p, parallel to the film plane, with pixel
   // length r;
   return 2*(p - Wpt(XYpt(PIXEL(p) + VEXEL(r/2,0)), p)).length();
}

inline double
obj_length(cWpt& o, double r, cWtransf& M, cWtransf& I)
{
   // same as above, but for object-space point o, with
   // transform M from object to world and its inverse I:
   Wpt w = M*o;
   return (o - I*Wpt(XYpt(PIXEL(w)+VEXEL(r,0)), w)).length();
}

// Returns true if the two line segments (p1,p2) and (q1,q2) intersect or 
// overlap, false otherwise.
//
template <class  P, class L>
inline bool 
intersect_segs(const L& line1, const L& line2, P& inter)
{
   P ap = line1.intersect(line2);
   P bp = line2.intersect(line1);
   if (ap.isEqual(bp)) {    // Lines intersect, do the line segments?
      inter = ap;

      // Is ap on line1 and line2?
      double len1 = line1.vector().length();
      double len2 = line2.vector().length();
      double dot1 = (ap - line1.point()) * line1.vector() / len1;
      if (dot1 <= len1  && dot1 >= 0) {
          double dot2 = (ap - line2.point()) * line2.vector() / len2;
      if (dot2 <= len2 && dot2 >= 0) 
             return 1;
      } 
   } 
   return 0;
}


#endif // POINTS_H

/* end of file points.H */

---