point.h

Go to the documentation of this file.

/**
 * \file point.h <mi32/point.h>
 * \brief Definitions for 2D and 3D point structures
 *
 * \if NODOC
 * $Id: point.h_v 1.53 2005/01/11 18:16:55 vdronov Exp $
 *
 * $Log: point.h_v $
 * Revision 1.53  2005/01/11 18:16:55  vdronov
 * added GetDistance and GetDistanceSquared from point to origin for DPOINT3D
 *
 * Revision 1.52  2004/11/16 17:14:03  dwilliss
 * Added a TruncateToLong method to DPOINT2D
 *
 * Revision 1.51  2004/09/02 14:42:49  scowan
 * Added more swap bytes external functions.
 *
 * Revision 1.50  2004/08/11 23:05:14  vdronov
 * *** empty log message ***
 *
 * Revision 1.49  2004/06/21 17:47:46  mju
 * Add Get/SetOrdinate to dpoint2d.
 *
 * Revision 1.48  2004/03/22 18:51:58  mju
 * Use double parms for DPOINT3DH instead of floata.
 *
 * Revision 1.47  2004/02/03 16:50:59  scowan
 * Added copy ctors for dpoint 3d and fpoint 3d.
 *
 * Revision 1.46  2003/09/25 21:29:07  dwilliss
 * Don't capitalize enum any more. Genitor needed it, doxygen doesn't like it.
 *
 * Revision 1.45  2003/09/23 17:56:05  dwilliss
 * Added a CrossProduct method to DPOINT3D
 *
 * Revision 1.44  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.43  2003/08/14 19:48:35  vdronov
 * small changes.
 *
 * Revision 1.42  2003/02/21 15:20:00  mju
 * Add SwapBytes methods.
 * Change return-by-value operators to do computation and construction when return so may optimize better.
 *
 * Revision 1.41  2003/02/06 18:53:11  msmith
 * Added == and != to FPOINT2D and FPOINT3D
 *
 * Revision 1.40  2003/02/03 21:25:23  vdronov
 * added some const to FPOINT
 *
 * Revision 1.39  2003/02/03 20:32:35  vdronov
 * changed DotProduct and CrossProduct
 *
 * Revision 1.38  2003/01/27 16:31:35  vdronov
 * added some methods for FPOINT2D and FPOINT3D
 *
 * Revision 1.37  2003/01/24 23:41:47  vdronov
 * added some methods for FPOINT2d
 *
 * Revision 1.36  2003/01/24 23:34:53  vdronov
 * changed some parameters from by value to by reference for FPOINT2D and FPOINT3D
 *
 * Revision 1.35  2002/12/05 15:26:40  vdronov
 * fixed warnings
 *
 * Revision 1.34  2002/11/27 21:39:37  vdronov
 * FPOINT3DH
 *
 * Revision 1.33  2002/11/20 22:02:12  vdronov
 * class DPOINT3DH added
 *
 * Revision 1.32  2002/10/10 14:57:33  msmith
 * Added operators to FPOINT2D
 *
 * Revision 1.31  2002/08/12 22:59:36  vdronov
 * added operators for DPOINT3D
 *
 * Revision 1.29  2002/05/17 15:34:31  dwilliss
 * Don't leave dangling commas on the last item in an enum.  It makes the
 * Mac give a compiler warning, making it hard to find the real errors in
 * their poorly formatted error messages
 *
 * Revision 1.28  2002/02/19 15:36:12  scowan
 * More docs.
 *
 * Revision 1.27  2002/02/13 16:29:47  vdronov
 * added 2 methods to DPOINT2D
 *
 * Revision 1.26  2002/02/08 16:43:10  scowan
 * Uses round macro for better speed.
 *
 * Revision 1.25  2002/02/08 16:41:03  vdronov
 * added DPOINT2D operators
 *
 * Revision 1.24  2002/01/29 21:40:40  scowan
 * Added get angle.
 *
 * Revision 1.23  2001/12/20 21:34:35  mju
 * Enum docs.
 *
 * Revision 1.22  2001/12/11 16:22:55  scowan
 * Added swapping fpoint 2d's.
 *
 * Revision 1.18  2001/07/19 21:31:35  msmith
 * Fixed operators.
 *
 * Revision 1.17  2001/07/19 21:27:30  msmith
 * Added FPOINT3D operators: + - * / += -= *= /=
 *
 * Revision 1.15  2001/06/13 16:54:06  mju
 * Added FPOINT3D operators
 *
 * Revision 1.14  2001/03/26 21:31:28  msmith
 * Add comparison operators for WPOINT3D.
 *
 * Revision 1.13  2001/03/14 16:17:42  mju
 * Add comparison operators for LPOINT2D.
 *
 * Revision 1.12  2001/01/09 14:57:31  scowan
 * Include memory buffer include file.
 *
 * Revision 1.11  2001/01/09 00:35:04  scowan
 * Added swap functions for points.
 *
 * Revision 1.10  2001/01/08 17:47:38  scowan
 * Added 3D point comparison operators.
 *
 * Revision 1.9  2001/01/05 18:08:01  mju
 * Rename ORIENTATION values.
 *
 * Revision 1.8  2001/01/05 17:37:50  scowan
 * Added orient and dimension enums.
 *
 * Revision 1.7  2000/07/07 21:47:16  sparsons
 * Genitor documentation.
 *
 * Revision 1.6  1999/07/21 21:13:20  dwilliss
 * In an assignment operator overload *this = rhs is an efficient
 * way to fill the stack but not real useful otherwise
 *
 * Revision 1.1  1999/05/05  17:29:49  mju
 * Initial revision
 * \endif
**/

#ifndef  INC_MI32_POINT_H
#define  INC_MI32_POINT_H

//!*****************************************************************************
//!      The structures defined here must not change in size as they are stored
//!      in many existing data files, as well as passed to DLLs.  The members
//!      must remain public and their names may not be changed for any reason.
//!*****************************************************************************

#ifndef  INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#ifndef  INC_MI32_MEMBUF_H
#include <mi32/membuf.h>
#endif

#ifdef ALLOW_NAMESPACES
   #include <cmath>
#else
   #include <math.h>
#endif

//-----------------------------------------------------------------------------
// Global enumerations used in dealing with objects that use points
//-----------------------------------------------------------------------------


//! Enumeration of dimension types.
enum DIMENSION {
   DIMENSION_2D = 0,             //!< 2 dimensional
   DIMENSION_3D = 1              //!< 3 dimensional
   };

//! Enumeration of orientation types assuming right-hand Cartesian system where
//! counter-clocksize sweep from +X axis to +Y axis is 90 degrees.
enum ORIENTATION {
   ORIENTATION_Unknown =            0, //!< Orientation is unknown or cannot be computed
   ORIENTATION_CounterClockwise =   1, //!< Counter-clockwise
   ORIENTATION_Clockwise =          2, //!< Clockwise
   ORIENTATION_EmptyPolygon =       3  //!< Polygon is empty, area is 0
   };


#ifndef GENERATING_DOXYGEN_OUTPUT
//! Forward declarations.
struct DPOINT3D;
#endif //!< GENERATING_DOXYGEN_OUTPUT

//-----------------------------------------------------------------------------
//!      Define simple structures for use in unions
//!      These structures must not have constructors/destructors
//-----------------------------------------------------------------------------

struct DPOINT2D_OLD {

   double x;
   double y;

   //! Assignment.
   inline DPOINT2D_OLD& operator= (
      const DPOINT2D& rhs
      );

   CHECKSIZE(16);
   };

struct DPOINT3D_OLD {

   double x;
   double y;
   double z;

   //! Assignment.
   inline DPOINT3D_OLD& operator= (
      const DPOINT3D& rhs
      );

   CHECKSIZE(24);
   };


//-------------------------------------------------------------------------------------------------------------------

//! 2D point using 16-bit integer coordinates.
struct WPOINT2D {

   INT16 x;
   INT16 y;

   //! Default constructor, performs no initialization.
   WPOINT2D (                          
      ) {
      }

   //! Initialization constructor.
   WPOINT2D (                          
      INT16 dx,
      INT16 dy
      ) : x(dx), y(dy) {
      }

   CHECKSIZE(4);                       
   };


//-------------------------------------------------------------------------------------------------------------------

//! 3D point using 16-bit integer coordinates.
struct WPOINT3D : public WPOINT2D {

   INT16 z;

   //! Default constructor, performs no initialization.
   WPOINT3D (                          
      ) {
      }

   //! Initialize from separate X, Y, Z values.
   WPOINT3D (                          
      const INT16 dx,
      const INT16 dy,
      const INT16 dz
      ) : WPOINT2D(dx,dy), z(dz) {
      }

   //! Initialize from WPOINT2D.
   WPOINT3D (                          
      const WPOINT2D& rhs
      ) : WPOINT2D(rhs), z(0) {
      }

   //! Make compiler validate structure size.
   CHECKSIZE(6);                       
   };

//! Equal to: Exact match, no fuzzy test enabled.
inline bool operator== (               
   const WPOINT3D& lhs, 
   const WPOINT3D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
   }

//! Not equal to: Exact match, no fuzzy test enabled.
inline bool operator!= (               
   const WPOINT3D& lhs, 
   const WPOINT3D& rhs
   ) {
   return (lhs.x != rhs.x || lhs.y != rhs.y || lhs.z != rhs.z);
   }


//-------------------------------------------------------------------------------------------------------------------

//! 2D point using 32-bit integer coordinates.
struct LPOINT2D {

   INT32 x;
   INT32 y;

   //! Default constructor, performs no initialization.
   LPOINT2D (                          
      ) {
      }

   //! Initialization constructor.
   LPOINT2D (                          
      INT32 dx,
      INT32 dy
      ) : x(dx), y(dy) {
      }

   //! Construction from WPOINT2D.
   LPOINT2D (                          
      const WPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   //! Explicit conversion from DPOINT2D to LPOINT2D, no rounding.
   explicit inline LPOINT2D (          
      const DPOINT2D& pt
      );

   //! Assignment from WPOINT2D.
   LPOINT2D& operator= (               
      const WPOINT2D& rhs
      ) { x = rhs.x; y = rhs.y; return (*this); }

   //! Assignment from DPOINT2D without rounding.
   inline LPOINT2D& operator= (        
      const DPOINT2D& pt
      );

   //! Perform byte-swapping.
   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); }

   //! Make compiler validate structure size.
   CHECKSIZE(8);                       
   };

//! Equality.
inline bool operator== (               
   const LPOINT2D& lhs, 
   const LPOINT2D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y);
   }

//! Inequality.
inline bool operator!= (               
   const LPOINT2D& lhs, 
   const LPOINT2D& rhs
   ) {
   return (lhs.x != rhs.x || lhs.y != rhs.y);
   }

//! Perform byte-swapping.
inline void SwapBytes (
   LPOINT2D& pt
   ) {
   pt.SwapBytes();
   }


//-------------------------------------------------------------------------------------------------------------------

//! 3D point using 32-bit integer coordinates.
struct LPOINT3D : public LPOINT2D {
   
   INT32 z;

   //! Default constructor, performs no initialization.
   LPOINT3D (                          
      ) { }

   //! Initialize from separate X, Y, Z values.
   LPOINT3D (                          
      const INT32 dx,
      const INT32 dy,
      const INT32 dz
      ) : LPOINT2D(dx,dy), z(dz) { }

   //! Initialize from LPOINT2D.
   LPOINT3D (                          
      const LPOINT2D& rhs
      ) : LPOINT2D(rhs), z(0) { }

   //! Perform byte-swapping.
   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); ::SwapBytes(z); }

   //! Make compiler validate structure size.
   CHECKSIZE(12);                      
   };

//! Perform byte-swapping.
inline void SwapBytes (
   LPOINT3D& pt
   ) {
   pt.SwapBytes();
   }


//-------------------------------------------------------------------------------------------------------------------

//! 2D point using 32-bit 'float' coordinates.
struct FPOINT2D {

   float x;
   float y;

   //! Default constructor, performs no initialization.
   FPOINT2D (                          
      ) { }

   //! Initialization constructor.
   FPOINT2D (                         
      float dx,
      float dy
      ) : x(dx), y(dy) { }

   //! Construction from WPOINT2D.
   FPOINT2D (                          
      const WPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   //! Assignment from WPOINT2D.
   FPOINT2D& operator= (               
      const WPOINT2D& rhs
      ) { x = rhs.x; y = rhs.y; return (*this); }

   //! Assignment from DPOINT2D
   FPOINT2D& operator= (               
      const DPOINT2D& rhs
      );

   //! Negation operator
   FPOINT2D operator- (
      ) const { return (FPOINT2D(-x,-y)); }

   //! Addition operator
   FPOINT2D operator+ (
      const FPOINT2D& rhs
      ) const { return (FPOINT2D(x+rhs.x,y+rhs.y)); }

   //! Subtraction operator
   FPOINT2D operator- (
      const FPOINT2D& rhs
      ) const { return (FPOINT2D(x-rhs.x,y-rhs.y)); }

   //! Multiplication operator
   FPOINT2D operator* (
      const float rhs
      ) const { return (FPOINT2D(x*rhs,y*rhs)); }

   //! Division operator
   FPOINT2D operator/ (
      const float rhs
      ) const { return (FPOINT2D(x/rhs,y/rhs)); }

   //! Plus equals operator
   FPOINT2D operator+= (
      const FPOINT2D& rhs
      ) { x += rhs.x; y += rhs.y; return (*this); }

   //! Minus equals operator
   FPOINT2D operator-= (
      const FPOINT2D& rhs
      ) { x -= rhs.x; y -= rhs.y; return (*this); }

   //! Times equals operator
   FPOINT2D operator*= (
      const float rhs
      ) { x *= rhs; y *= rhs; return (*this); }

   //! Divided by equals operator
   FPOINT2D operator/= (
      const float rhs
      ) { x /= rhs; y /= rhs; return (*this); }

   //! Return distance between two points.
   float GetDistance (                 
      const FPOINT2D& pt
      ) const {
      float dx(pt.x - x);
      float dy(pt.y - y);
      return (static_cast<float>(sqrt(dx*dx + dy*dy)));
      }

   //! Return distance between origin and point.
   float GetDistance (                 
      ) const {
      return (static_cast<float>(sqrt(x*x + y*y)));
      }

   //! Return squared distance between two points.
   float GetDistanceSquared (       
      const FPOINT2D& pt
      ) const {
      float dx(pt.x - x);
      float dy(pt.y - y);
      return (static_cast<float>(dx*dx + dy*dy));
      }

   //! Return squared distance between origin and point.
   float GetDistanceSquared (       
      ) const {
      return (static_cast<float>(x*x + y*y));
      }

   //! Normalize
   bool Normalize (        
      ) {
      const float d = GetDistance();
      if (d == 0.0f) return false;
      *this /= d;
      return true;
      }

   //! Normalize
   static bool Normalize (       
      FPOINT2D& pt
      ) {
      const float d = pt.GetDistance();
      if (d == 0.0f) return false;
      pt /= d;
      return true;
      }

   //! Dot product
   float DotProduct (         
      const FPOINT2D& pt
      ) const { return (x*pt.x + y*pt.y); }

   //! Cross product
   float CrossProduct (       
      const FPOINT2D& pt
      ) const { return (x*pt.y - y*pt.x); }

   //! Perform byte-swapping.
   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); }

   //! Make compiler validate structure size.
   CHECKSIZE(8);                       
   };

//! Exact equality.
inline bool operator== (               
   const FPOINT2D& lhs, 
   const FPOINT2D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y);
   }

//! Exact inequality.
inline bool operator!= (               
   const FPOINT2D& lhs, 
   const FPOINT2D& rhs
   ) {
   return (lhs.x != rhs.x || lhs.y != rhs.y);
   }

//! Perform byte-swapping.
inline void SwapBytes (
   FPOINT2D& pt
   ) {
   pt.SwapBytes();
   }


//-------------------------------------------------------------------------------------------------------------------

//! 3D point using 32-bit 'float' coordinates.
struct FPOINT3D : public FPOINT2D {

   float z;

   //! Default constructor, performs no initialization.
   FPOINT3D (                          
      ) {
      }

   //! Copy constructor
   FPOINT3D (
      const FPOINT3D& rhs
      ) : FPOINT2D(rhs.x, rhs.y), z(rhs.z) { }

   //! Initialize from separate X, Y, Z values.
   FPOINT3D (                          
      const float dx,
      const float dy,
      const float dz
      ) : FPOINT2D(dx,dy), z(dz) {
      }

   //! Initialize from FPOINT2D.
   FPOINT3D (                          
      const FPOINT2D& rhs
      ) : FPOINT2D(rhs), z(0.0F) {
      }

   //! Assignment from DPOINT3D
   FPOINT3D& operator= (               
      const DPOINT3D& rhs
      );

   //! Negation operator
   FPOINT3D operator- (
      ) const { return (FPOINT3D(-x,-y,-z)); }

   //! Addition operator
   FPOINT3D operator+ (
      const FPOINT3D& rhs
      ) const { return (FPOINT3D(x+rhs.x,y+rhs.y,z+rhs.z)); }

   //! Subtraction operator
   FPOINT3D operator- (
      const FPOINT3D& rhs
      ) const { return (FPOINT3D(x-rhs.x,y-rhs.y,z-rhs.z)); }

   //! Multiplication operator
   FPOINT3D operator* (
      const float rhs
      ) const { return (FPOINT3D(x*rhs,y*rhs,z*rhs)); }

   //! Division operator
   FPOINT3D operator/ (
      const float rhs
      ) const { return (FPOINT3D(x/rhs,y/rhs,z/rhs)); }

   //! Plus equals operator
   FPOINT3D operator+= (
      const FPOINT3D& rhs
      ) { x += rhs.x; y += rhs.y; z += rhs.z; return (*this); }

   //! Minus equals operator
   FPOINT3D operator-= (
      const FPOINT3D& rhs
      ) { x -= rhs.x; y -= rhs.y; z -= rhs.z; return (*this); }

   //! Times equals operator
   FPOINT3D operator*= (
      const float rhs
      ) { x *= rhs; y *= rhs; z *= rhs; return (*this); }

   //! Divided by equals operator
   FPOINT3D operator/= (
      const float rhs
      ) { x /= rhs; y /= rhs; z /= rhs; return (*this); }

   //! Return distance between two points.
   float GetDistance (                 
      const FPOINT3D& pt
      ) const {
      float dx(pt.x - x);
      float dy(pt.y - y);
      float dz(pt.z - z);
      return (static_cast<float>(sqrt(dx*dx + dy*dy + dz*dz)));
      }

   //! Return distance between origin and point.
   float GetDistance (                 
      ) const {
      return (static_cast<float>(sqrt(x*x + y*y + z*z)));
      }

   //! Return squared distance between two points.
   float GetDistanceSquared (       
      const FPOINT3D& pt
      ) const {
      float dx(pt.x - x);
      float dy(pt.y - y);
      float dz(pt.z - z);
      return (static_cast<float>(dx*dx + dy*dy + dz*dz));
      }

   //! Return squared distance between origin and point.
   float GetDistanceSquared (       
      ) const {
      return (static_cast<float>(x*x + y*y + z*z));
      }

   //! Normalize
   bool Normalize (        
      ) {
      const float d = GetDistance();
      if (d == 0.0f) return false;
      *this /= d;
      return true;
      }

   //! Normalize
   static bool Normalize (       
      FPOINT3D& pt
      ) {
      const float d = pt.GetDistance();
      if (d == 0.0f) return false;
      pt /= d;
      return true;
      }

   //! Dot product
   float DotProduct (         
      const FPOINT3D& pt
      ) const { return (x*pt.x + y*pt.y + z*pt.z); }

   //! Cross product
   FPOINT3D CrossProduct (       
      const FPOINT3D& pt
      ) const { return (FPOINT3D(y*pt.z - z*pt.y, z*pt.x - x*pt.z, x*pt.y - y*pt.x)); }

   //! Perform byte-swapping.
   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); ::SwapBytes(z); }

   //! Make compiler validate structure size.
   CHECKSIZE(12);                      
   };

//! Equal to: Exact match, no fuzzy test enabled.
inline bool operator== (               
   const FPOINT3D& lhs, 
   const FPOINT3D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
   }

//! Not equal to: Exact match, no fuzzy test enabled.
inline bool operator!= (               
   const FPOINT3D& lhs, 
   const FPOINT3D& rhs
   ) {
   return (lhs.x != rhs.x || lhs.y != rhs.y || lhs.z != rhs.z);
   }

//! Perform byte swapping.
inline void SwapBytes (
   FPOINT3D& pt
   ) {
   pt.SwapBytes();
   }


//-------------------------------------------------------------------------------------------------------------------

//! 2D point using 64-bit 'double' coordinates.
struct DPOINT2D {

   double x;
   double y;

   //! Default constructor.
   DPOINT2D (                          
      ) { }

   //! Initialization from separate x and y values.
   DPOINT2D (                          
      const double dx,
      const double dy
      ) : x(dx), y(dy) { }

   //! Construction from WPOINT2D.
   DPOINT2D (                          
      const WPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   //! Construction from LPOINT2D.
   DPOINT2D (                          
      const LPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   //! Construction from FPOINT2D.
   DPOINT2D (                          
      const FPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   //! Construction from DPOINT2D_OLD.
   DPOINT2D (
      const DPOINT2D_OLD& pt
      ) : x(pt.x), y(pt.y) { }

   //! Assignment from WPOINT2D.
   DPOINT2D& operator= (               
      const WPOINT2D& rhs
      ) { x = rhs.x; y = rhs.y; return (*this); }

   //! Assignment from LPOINT2D.
   DPOINT2D& operator= (               
      const LPOINT2D& rhs
      ) { x = rhs.x; y = rhs.y; return (*this); }

   //! Assignment from FPOINT2D.
   DPOINT2D& operator= (               
      const FPOINT2D& rhs
      ) { x = rhs.x; y = rhs.y; return (*this); }

   //! Assignment from DPOINT2D_OLD.
   DPOINT2D& operator= (               
      const DPOINT2D_OLD& rhs
      ) { x = rhs.x; y = rhs.y; return (*this); }
      
   //! Negation operator
   DPOINT2D operator- (
      ) { return (DPOINT2D(-x,-y)); }

   //! Addition operator
   DPOINT2D operator+ (
      const DPOINT2D& rhs
      ) const { return (DPOINT2D(x+rhs.x,y+rhs.y)); }

   //! Subtraction operator
   DPOINT2D operator- (
      const DPOINT2D& rhs
      ) const { return (DPOINT2D(x-rhs.x,y-rhs.y)); }

   //! Multiplication operator
   DPOINT2D operator* (
      const double rhs
      ) const { return (DPOINT2D(x*rhs,y*rhs)); }

   //! Division operator
   DPOINT2D operator/ (
      const double rhs
      ) const { return (DPOINT2D(x/rhs,y/rhs)); }

   //! Plus equals operator
   DPOINT2D operator+= (
      const DPOINT2D& rhs
      ) { x += rhs.x; y += rhs.y; return (*this); }

   //! Minus equals operator
   DPOINT2D operator-= (
      const DPOINT2D& rhs
      ) { x -= rhs.x; y -= rhs.y; return (*this); }

   //! Times equals operator
   DPOINT2D operator*= (
      const double rhs
      ) { x *= rhs; y *= rhs; return (*this); }

   //! Divided by equals operator
   DPOINT2D operator/= (
      const double rhs
      ) { x /= rhs; y /= rhs; return (*this); }

   //! Return angle of the segment, 'this' is the basepoint
   double GetAngle (
      const DPOINT2D& pt
      ) const {
      double dx(pt.x - x);
      double dy(pt.y - y);
      if (dx == 0.0 && dy == 0.0) return (0.0);
      return (atan2(dy, dx));
      }

   //! Return angle of the segment from origin to point
   double GetAngle (
      ) const {
      if (x == 0.0 && y == 0.0) return (0.0);
      return (atan2(y, x));
      }

   //! Return distance between two points.
   double GetDistance (                
      const DPOINT2D& pt
      ) const {
      double dx(pt.x - x);
      double dy(pt.y - y);
      return (sqrt(dx*dx + dy*dy));
      }

   //! Return distance between origin and point.
   double GetDistance (
      ) const {
      return (sqrt(x*x + y*y));
      }

   //! Return squared distance between two points.
   double GetDistanceSquared (         
      const DPOINT2D& pt
      ) const {
      double dx(pt.x - x);
      double dy(pt.y - y);
      return (dx*dx + dy*dy);
      }

   //! Get ordinate at specified index.
   //! Allows access like array of appropriate dimension (2 or 3).
   double GetOrdinate (
      int index                     //!< Index (0-1) or (0-2) if 3D.
      ) const { return (reinterpret_cast<const double*>(this)[index]); }

   //! Convert the a DPOINT2D into an LPOINT2D.
   LPOINT2D RoundToLong (              
      ) const {
      return (LPOINT2D(FAST_ROUND(x), FAST_ROUND(y)));
      }

   //! Set ordinate at specified index.
   //! Allows access like array of appropriate dimension (2 or 3).
   void SetOrdinate (
      int index,                    //!< Index (0-1) or (0-2) if 3D.
      double value
      ) { reinterpret_cast<double*>(this)[index] = value; }

   //! Shift point using another point.
   void Shift (                        
      const DPOINT2D& value
      ) {
      x += value.x;
      y += value.y;
      return;
      }

   //! Shift point by a single value.
   void Shift (                        
      const double xval,
      const double yval
      ) {
      x += xval;
      y += yval;
      return;
      }

   //! Perform byte-swapping.
   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); }

   //! Convert the a DPOINT2D into an LPOINT2D.
   LPOINT2D TruncateToLong (              
      ) const {
      return (LPOINT2D(FAST_TRUNCATE(x), FAST_TRUNCATE(y)));
      }

   //! Make compiler validate structure size.
   CHECKSIZE(16);                      
   };


//! Equal to: Exact match, no fuzzy test enabled.
inline bool operator== (               
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y);
   }

//! Not equal to: Exact match, no fuzzy test enabled.
inline bool operator!= (               
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs.x != rhs.x || lhs.y != rhs.y);
   }

//! Less than: Exact match, no fuzzy test enabled.
inline bool operator< (                
   const DPOINT2D& lhs,
   const DPOINT2D& rhs
   ) {
   return (lhs.x < rhs.x || (lhs.x == rhs.x && lhs.y < rhs.y));
   }

//! Greater than: Exact match, no fuzzy test enabled.
inline bool operator> (                
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs.x > rhs.x || (lhs.x == rhs.x && lhs.y > rhs.y));
   }

//! Less than or equal to: Exact match, no fuzzy test enabled.
inline bool operator<= (               
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs == rhs || lhs < rhs);
   }

//! Greater than or equal to: Exact match, no fuzzy test enabled.
inline bool operator>= (              
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs == rhs || lhs > rhs);
   }

//! Perform byte-swapping.
inline void SwapBytes (
   DPOINT2D& pt
   ) {
   pt.SwapBytes();
   }


//-------------------------------------------------------------------------------------------------------------------

//! 3D point using 64-bit 'double' coordinates.
struct DPOINT3D : public DPOINT2D {

   double z;

   //! Default constructor, performs no initialization.
   DPOINT3D (                          
      ) {
      }

   //! Copy constructor
   DPOINT3D (
      const DPOINT3D& rhs
      ) : DPOINT2D(rhs.x, rhs.y), z(rhs.z) { }

   //! Initialize from separate X, Y, Z values.
   DPOINT3D (                          
      const double dx,
      const double dy,
      const double dz
      ) : DPOINT2D(dx, dy), z(dz) { }

   //! Initialize from DPOINT2D.
   DPOINT3D (                          
      const DPOINT2D& rhs
      ) : DPOINT2D(rhs), z(0.0) { }

   //! Implicit conversion from DPOINT3D_OLD.
   DPOINT3D (                          
      const DPOINT3D_OLD& rhs
      ) : DPOINT2D(rhs.x,rhs.y), z(rhs.z) { }

   //! Assignment from DPOINT2D.
   DPOINT3D& operator= (               
      const DPOINT2D& rhs
      ) { x = rhs.x; y = rhs.y; z = 0.0; return (*this); }

   //! Assignment from FPOINT3D.
   DPOINT3D& operator= (               
      const FPOINT3D& rhs
      ) { x = rhs.x; y = rhs.y; z = rhs.z; return (*this); }

   //! Assignment from DPOINT3D_OLD.
   DPOINT3D& operator= (               
      const DPOINT3D_OLD& rhs
      ) { x = rhs.x; y = rhs.y; z = rhs.z; return (*this); }

   //! Negation operator
   DPOINT3D operator- (
      ) const { return (DPOINT3D(-x,-y,-z)); }

   //! Addition operator
   DPOINT3D operator+ (
      const DPOINT3D& rhs
      ) const { return (DPOINT3D(x+rhs.x,y+rhs.y,z+rhs.z)); }

   //! Subtraction operator
   DPOINT3D operator- (
      const DPOINT3D& rhs
      ) const { return (DPOINT3D(x-rhs.x,y-rhs.y,z-rhs.z)); }

   //! Multiplication operator
   DPOINT3D operator* (
      const double rhs
      ) const { return (DPOINT3D(x*rhs,y*rhs,z*rhs)); }

   //! Division operator
   DPOINT3D operator/ (
      const double rhs
      ) const { return (DPOINT3D(x/rhs,y/rhs,z/rhs)); }

   //! Plus equals operator
   DPOINT3D operator+= (
      const DPOINT3D& rhs
      ) { x += rhs.x; y += rhs.y; z += rhs.z; return (*this); }

   //! Minus equals operator
   DPOINT3D operator-= (
      const DPOINT3D& rhs
      ) { x -= rhs.x; y -= rhs.y; z -= rhs.z; return (*this); }

   //! Times equals operator
   DPOINT3D operator*= (
      const double rhs
      ) { x *= rhs; y *= rhs; z *= rhs; return (*this); }

   //! Divided by equals operator
   DPOINT3D operator/= (
      const double rhs
      ) { x /= rhs; y /= rhs; z /= rhs; return (*this); }

   //! Compute the cross product of two DPOINT3Ds
   //! @note "this" cannot be either of the two input points
   void CrossProduct (
      const DPOINT3D& in1,
      const DPOINT3D& in2
      ) {
      x = in1.y * in2.z - in2.y * in1.z;
      y = in1.z * in2.x - in2.z * in1.x;
      z = in1.x * in2.y - in2.x * in1.y;
      }

   //! Compute the dot product of two DPOINT3Ds
   static double DotProduct (
      const DPOINT3D& in1,
      const DPOINT3D& in2
      ) {
      return (in1.x * in2.x + in1.y * in2.y + in1.z * in2.z);
      }

   //! Return distance between origin and point.
   double GetDistance (                
      ) const {
      return (sqrt(x*x + y*y + z*z));
      }

   //! Return distance between two points.
   double GetDistance (                
      const DPOINT3D& pt
      ) const {
      double dx(pt.x - x);
      double dy(pt.y - y);
      double dz(pt.z - z);
      return (sqrt(dx*dx + dy*dy + dz*dz));
      }

   //! Return squared distance between two points.
   double GetDistanceSquared (         
      const DPOINT3D& pt
      ) const {
      double dx(pt.x - x);
      double dy(pt.y - y);
      double dz(pt.z - z);
      return (dx*dx + dy*dy + dz*dz);
      }

   //! Return squared distance between origin and point.
   double GetDistanceSquared (         
      ) const {
      return (x*x + y*y + z*z);
      }

   //! Normalize 3D vector represented by point.
   void Normalize (                    
      ) {
      double d = sqrt(x*x + y*y + z*z);
      if (d != 0.0) {
         x /= d;
         y /= d;
         z /= d;
         }
      return;
      }

   //! Shift point using another point.
   void Shift (                        
      const DPOINT3D& value
      ) { DPOINT2D::Shift(value); z += value.z; }

   //! Shift point by a single value.                                         
   void Shift (                        
      const double xval,
      const double yval,
      const double zval
      ) { DPOINT2D::Shift(xval, yval); z += zval; }

   //! Perform byte-swapping.
   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); ::SwapBytes(z); }

   //! Make compiler validate structure size.
   CHECKSIZE(24);                      
   };


//-------------------------------------------------------------------------------------------------------------------

//! 3D homogeneous point using 32-bit 'float' coordinates.
struct FPOINT3DH {

   float x;
   float y;
   float z;
   float w;

   //! Default constructor initialize with (0.0, 0.0, 0.0, 1.0).
   FPOINT3DH (
      ) : x(0.0f), y(0.0f), z(0.0f), w(1.0f) { }

   //! Initialize from separate X, Y, Z, W values.
   FPOINT3DH (                         
      const float dx,
      const float dy,
      const float dz,
      const float dw = 1.0f
      ) : x(dx), y(dy), z(dz), w(dw) { }

   //! Initialize from FPOINT3D.
   FPOINT3DH (                         
      const FPOINT3D& p
      ) : x(p.x), y(p.y), z(p.z), w(1.0f) { }

   //! Assignment from FPOINT3D
   FPOINT3DH& operator= (              
      const FPOINT3D& rhs
      ) { x = rhs.x; y = rhs.y; z = rhs.z; w = 1.0f; return (*this); }

   //! Assignment from DPOINT3DH
   inline FPOINT3DH& operator= (             
      const DPOINT3DH& rhs
      );

   //! Negation operator
   FPOINT3DH operator- (
      ) const { return (FPOINT3DH(-x,-y,-z,-w)); }

   //! Addition operator
   FPOINT3DH operator+ (
      const FPOINT3DH& rhs
      ) const { return (FPOINT3DH(x+rhs.x,y+rhs.y,z+rhs.z,w+rhs.w)); }

   //! Subtraction operator
   FPOINT3DH operator- (
      const FPOINT3DH& rhs
      ) const { return (FPOINT3DH(x-rhs.x,y-rhs.y,z-rhs.z,w-rhs.w)); }

   //! Multiplication operator
   FPOINT3DH operator* (
      const float rhs
      ) const { return (FPOINT3DH(x*rhs,y*rhs,z*rhs,w*rhs)); }

   //! Division operator
   FPOINT