mi32/point.h

Go to the documentation of this file.

#ifndef  INC_MI32_POINT_H
#define  INC_MI32_POINT_H


#ifndef  INC_MI32_INIBASE_H
#include <mi32/inibase.h>
#endif

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

#ifndef  INC_MI32_MATH_H
#include <mi32/math.h>
#endif

#ifdef ALLOW_NAMESPACES
   #include <cmath>
#endif

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


enum DIMENSION {
   DIMENSION_2D = 0,             
   DIMENSION_3D = 1              
   };

enum ORIENTATION {
   ORIENTATION_Unknown =            0, 
   ORIENTATION_CounterClockwise =   1, 
   ORIENTATION_Clockwise =          2, 
   ORIENTATION_EmptyPolygon =       3  
   };


#ifndef GENERATING_DOXYGEN_OUTPUT
struct DPOINT3D;
#endif 

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

struct DPOINT2D_OLD {

   double x;
   double y;

   inline DPOINT2D_OLD& operator= (
      const DPOINT2D& rhs
      );

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(16);
   #endif
   };

struct DPOINT3D_OLD {

   double x;
   double y;
   double z;

   inline DPOINT3D_OLD& operator= (
      const DPOINT3D& rhs
      );

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(24);
   #endif
   };


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

struct WPOINT2D {

   INT16 x;
   INT16 y;

   WPOINT2D (
      ) {
      }

   WPOINT2D (
      INT16 dx,
      INT16 dy
      ) : x(dx), y(dy) {
      }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(4);
   #endif
   };

inline bool operator== (
   const WPOINT2D& lhs, 
   const WPOINT2D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y);
   }

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


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

struct WPOINT3D : public WPOINT2D {

   INT16 z;

   WPOINT3D (
      ) {
      }

   WPOINT3D (
      const INT16 dx,
      const INT16 dy,
      const INT16 dz
      ) : WPOINT2D(dx,dy), z(dz) {
      }

   WPOINT3D (
      const WPOINT2D& rhs
      ) : WPOINT2D(rhs), z(0) {
      }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(6);
   #endif
   };

inline bool operator== (
   const WPOINT3D& lhs, 
   const WPOINT3D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
   }

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


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

struct LPOINT2D {

   INT32 x;
   INT32 y;

   LPOINT2D (
      ) {
      }

   LPOINT2D (
      INT32 dx,
      INT32 dy
      ) : x(dx), y(dy) {
      }

   LPOINT2D (
      const WPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   explicit inline LPOINT2D (
      const DPOINT2D& pt
      );

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

   inline LPOINT2D& operator= (
      const DPOINT2D& pt
      );

   LPOINT2D operator- (
      ) { return (LPOINT2D(-x,-y)); }

   LPOINT2D operator+ (
      const LPOINT2D& rhs
      ) const { return (LPOINT2D(x+rhs.x,y+rhs.y)); }

   LPOINT2D operator- (
      const LPOINT2D& rhs
      ) const { return (LPOINT2D(x-rhs.x,y-rhs.y)); }

   LPOINT2D operator+= (
      const LPOINT2D& rhs
      ) { x += rhs.x; y += rhs.y; return (*this); }

   LPOINT2D operator-= (
      const LPOINT2D& rhs
      ) { x -= rhs.x; y -= rhs.y; return (*this); }

   DEPRECATED_MSG("Use GetDistance2D") double GetDistance (
      const LPOINT2D& pt
      ) const { return (GetDistance2D(pt)); }

   double GetDistance2D (
      const LPOINT2D& pt
      ) const {
      double dx(pt.x - x);
      double dy(pt.y - y);
      return (sqrt(dx*dx + dy*dy));
      }

   // Set X/Y values.
   void Set (
      INT32 ix,
      INT32 iy
      ) { x = ix; y = iy; }

   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(8);
   #endif
   };

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

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

inline void SwapBytes (
   LPOINT2D& pt
   ) {
   pt.SwapBytes();
   }


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

struct LPOINT3D : public LPOINT2D {
   
   INT32 z;

   LPOINT3D (
      ) { }

   LPOINT3D (
      const INT32 dx,
      const INT32 dy,
      const INT32 dz
      ) : LPOINT2D(dx,dy), z(dz) { }

   explicit LPOINT3D (
      const LPOINT2D& rhs,
      INT32 iz = 0
      ) : LPOINT2D(rhs), z(iz) { }

   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); ::SwapBytes(z); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(12);
   #endif
   };

inline void SwapBytes (
   LPOINT3D& pt
   ) {
   pt.SwapBytes();
   }


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

struct FPOINT2D {

   float x;
   float y;

   FPOINT2D (
      ) { }

   FPOINT2D (  
      float dx,
      float dy
      ) : x(dx), y(dy) { }

   FPOINT2D (
      const WPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

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

   FPOINT2D& operator= (
      const DPOINT2D& rhs
      );

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

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

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

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

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

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

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

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

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

   DEPRECATED_MSG("Use GetDistance2D") float GetDistance (
      const FPOINT2D& pt
      ) const { return (GetDistance2D(pt)); }

   DEPRECATED_MSG("Use GetDistanceSquared2D") float GetDistanceSquared (
      const FPOINT2D& pt
      ) const { return (GetDistanceSquared2D(pt)); }

   float GetDistance2D (
      const FPOINT2D& pt
      ) const { return (static_cast<float>(sqrt(GetDistanceSquared2D(pt)))); }

   float GetDistanceSquared2D (
      const FPOINT2D& pt
      ) const {
      float dx(pt.x - x);
      float dy(pt.y - y);
      return (static_cast<float>(dx*dx + dy*dy));
      }

   float GetMagnitude2D (
      ) const { return (static_cast<float>(sqrt(GetMagnitudeSquared2D()))); }

   float GetMagnitudeSquared2D (
      ) const { return (static_cast<float>(x*x + y*y)); }

   bool Normalize (
      ) {
      const float m = GetMagnitude2D();
      if (m == 0.0F) return (false);
      *this /= m;
      return (true);
      }

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

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

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

   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(8);
   #endif
   };

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

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

inline void SwapBytes (
   FPOINT2D& pt
   ) {
   pt.SwapBytes();
   }


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

struct FPOINT3D : public FPOINT2D {

   float z;

   FPOINT3D (
      ) {
      }

   FPOINT3D (
      const FPOINT3D& rhs
      ) : FPOINT2D(rhs.x, rhs.y), z(rhs.z) { }

   FPOINT3D (
      const float dx,
      const float dy,
      const float dz
      ) : FPOINT2D(dx,dy), z(dz) {
      }

   FPOINT3D (
      const FPOINT2D& rhs
      ) : FPOINT2D(rhs), z(0.0F) {
      }

   FPOINT3D& operator= (
      const DPOINT3D& rhs
      );

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

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

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

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

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

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

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

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

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

   DEPRECATED_MSG("Use GetDistance3D/2D to avoid ambiguity") float GetDistance (
      const FPOINT3D& pt
      ) const { return (GetDistance3D(pt)); }

   DEPRECATED_MSG("Use GetDistanceSquared3D/2D to avoid ambiguity") float GetDistanceSquared (
      const FPOINT3D& pt
      ) const { return (GetDistanceSquared3D(pt)); }

   float GetDistance3D (
      const FPOINT3D& pt
      ) const { return (static_cast<float>(sqrt(GetDistanceSquared3D(pt)))); }

   float GetDistanceSquared3D (
      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));
      }

   float GetMagnitude3D (
      ) const { return (static_cast<float>(sqrt(GetMagnitudeSquared3D()))); }

   float GetMagnitudeSquared3D (
      ) const { return (static_cast<float>(x*x + y*y + z*z)); }

   bool Normalize (
      ) {
      const float d = GetMagnitude3D();
      if (d == 0.0F) return false;
      *this /= d;
      return true;
      }

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

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

   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)); }

   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); ::SwapBytes(z); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(12);
   #endif
   };

inline bool operator== (
   const FPOINT3D& lhs, 
   const FPOINT3D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
   }

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

inline void SwapBytes (
   FPOINT3D& pt
   ) {
   pt.SwapBytes();
   }


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

struct DPOINT2D {

   double x;
   double y;

   DPOINT2D (
      ) { }

   DPOINT2D (
      const double dx,
      const double dy
      ) : x(dx), y(dy) { }

   DPOINT2D (
      const WPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   DPOINT2D (
      const LPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   DPOINT2D (
      const FPOINT2D& pt
      ) : x(pt.x), y(pt.y) { }

   DPOINT2D (
      const DPOINT2D_OLD& pt
      ) : x(pt.x), y(pt.y) { }

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

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

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

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

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

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

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

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

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

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

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

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

   DPOINT2D ComputeMidpoint (
      const DPOINT2D& rhs
      ) const { return (DPOINT2D((x + rhs.x)/2.0, (y + rhs.y)/2.0)); }

   double DotProduct (
      const DPOINT2D& pt
      ) const { return (x*pt.x + y*pt.y); }

   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));
      }

   double GetAngle (
      ) const {
      if (x == 0.0 && y == 0.0) return (0.0);
      return (atan2(y, x));
      }

   DEPRECATED_MSG("Use GetDistance2D") double GetDistance (
      const DPOINT2D& pt
      ) const { return (GetDistance2D(pt)); }

   DEPRECATED_MSG("Use GetDistanceSquared2D") double GetDistanceSquared (
      const DPOINT2D& pt
      ) const { return (GetDistanceSquared2D(pt)); }

   double GetDistance2D (
      const DPOINT2D& pt
      ) const { return (sqrt(GetDistanceSquared2D(pt))); }

   double GetDistanceSquared2D (
      const DPOINT2D& pt
      ) const {
      double dx(pt.x - x);
      double dy(pt.y - y);
      return (dx*dx + dy*dy);
      }

   double GetMagnitude2D (
      ) const { return (sqrt(GetMagnitudeSquared2D())); }

   double GetMagnitudeSquared2D (
      ) const { return (x*x + y*y); }

   double GetOrdinate (
      int index                     
      ) const { return (reinterpret_cast<const double*>(this)[index]); }

   double GetX () const
      { return (x); }

   double GetY () const
      { return (y); }

   void Move (
      const double distance,  
      const double azimuth 
      ) {
      x += sin(azimuth * PI / 180) * distance;
      y += cos(azimuth * PI / 180) * distance;
      return;
      }

   void Normalize (
      ) {
      double d = GetMagnitude2D();
      if (d != 0.0) {
         x /= d;
         y /= d;
         }
      }

   LPOINT2D RoundToLongExact (
      ) const {
      return (LPOINT2D(FAST_ROUND_EXACT(x), FAST_ROUND_EXACT(y)));
      }

   LPOINT2D RoundToLongLimited (
      ) const {
      return (LPOINT2D(FAST_ROUND_LIMITED(x), FAST_ROUND_LIMITED(y)));
      }

   LPOINT2D RoundToLongNoLimit (
      ) const {
      return (LPOINT2D(FAST_ROUND_NOLIMIT(x), FAST_ROUND_NOLIMIT(y)));
      }

   LPOINT2D RoundToLongPositive (
      ) const {
      return (LPOINT2D(FAST_ROUND_POSITIVE(x), FAST_ROUND_POSITIVE(y)));
      }

   void Set (
      double ix,
      double iy
      ) { x = ix; y = iy; }

   void SetOrdinate (
      int index,                    
      double value
      ) { reinterpret_cast<double*>(this)[index] = value; }

   void SetX (
      double p_x
      ) { x = p_x; }

   void SetY (
      double p_y
      ) { y = p_y; }

   void Shift (
      const DPOINT2D& value
      ) {
      x += value.x;
      y += value.y;
      return;
      }

   void Shift (
      const double xval,
      const double yval
      ) {
      x += xval;
      y += yval;
      return;
      }

   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); }

   LPOINT2D TruncateToLong (
      ) const {
      return (LPOINT2D(FAST_TRUNCATE(x), FAST_TRUNCATE(y)));
      }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(16);
   #endif
   };


inline bool operator== (
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y);
   }

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

inline bool operator< (
   const DPOINT2D& lhs,
   const DPOINT2D& rhs
   ) {
   return (lhs.x < rhs.x || (lhs.x == rhs.x && lhs.y < rhs.y));
   }

inline bool operator> (
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs.x > rhs.x || (lhs.x == rhs.x && lhs.y > rhs.y));
   }

inline bool operator<= (
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs == rhs || lhs < rhs);
   }

inline bool operator>= (  
   const DPOINT2D& lhs, 
   const DPOINT2D& rhs
   ) {
   return (lhs == rhs || lhs > rhs);
   }

inline int IniRead (INIHANDLE hdl, const char *group, const char *field, DPOINT2D& value) { return (_iniRead(hdl,group,field,INITYPE_DPOINT2D,&value,1)); }

inline int IniRead (INIHANDLE hdl, const char *group, const char *field, DPOINT2D& value, const DPOINT2D& dft) { value = dft; return (IniRead(hdl,group,field,value)); }

inline int IniWrite (INIHANDLE hdl, const char *group, const char *field, const DPOINT2D& value) { return (_iniWrite(hdl,group,field,INITYPE_DPOINT2D,&value,1)); }

inline void SwapBytes (
   DPOINT2D& pt
   ) {
   pt.SwapBytes();
   }


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

struct DPOINT3D : public DPOINT2D {

   double z;

   DPOINT3D (
      ) {
      }

   DPOINT3D (
      const DPOINT3D& rhs
      ) : DPOINT2D(rhs.x, rhs.y), z(rhs.z) { }

   DPOINT3D (
      const double dx,
      const double dy,
      const double dz
      ) : DPOINT2D(dx, dy), z(dz) { }

   DPOINT3D (
      const DPOINT2D& rhs
      ) : DPOINT2D(rhs), z(0.0) { }

   DPOINT3D (
      const DPOINT3D_OLD& rhs
      ) : DPOINT2D(rhs.x,rhs.y), z(rhs.z) { }

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

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

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

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

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

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

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

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

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

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

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

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

   DPOINT3D ComputeMidpoint (
      const DPOINT3D& rhs
      ) const { return (DPOINT3D((x + rhs.x)/2.0, (y + rhs.y)/2.0, (z + rhs.z)/2.0)); }

   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;
      }

   static double DotProduct (
      const DPOINT3D& in1,
      const DPOINT3D& in2
      ) {
      return (in1.x * in2.x + in1.y * in2.y + in1.z * in2.z);
      }

   DEPRECATED_MSG("Use GetDistance3D/2D to avoid ambiguity") double GetDistance (
      const DPOINT3D& pt
      ) const { return (GetDistance3D(pt)); }

   DEPRECATED_MSG("Use GetDistanceSquared3D/2D to avoid ambiguity") double GetDistanceSquared (
      const DPOINT3D& pt
      ) const { return (GetDistanceSquared3D(pt)); }

   double GetDistance3D (
      const DPOINT3D& pt
      ) const { return (sqrt(GetDistanceSquared3D(pt))); }

   double GetDistanceSquared3D (
      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);
      }

   double GetMagnitude3D (
      ) const { return (sqrt(GetMagnitudeSquared3D())); }

   double GetMagnitudeSquared3D (
      ) const { return (x*x + y*y + z*z); }

   double GetZ () const
      { return (z); }

   void Move (
      const double distance,  
      const double azimuth,   
      const double elevation  
      ) {
      double delta = sqrt(distance*distance - elevation*elevation);
      x += sin(azimuth * PI / 180) * delta;
      y += cos(azimuth * PI / 180) * delta;
      z += elevation;
      return;
      }

   void Normalize (
      ) {
      double d = GetMagnitude3D();
      if (d != 0.0) {
         x /= d;
         y /= d;
         z /= d;
         }
      }

   // Set X/Y/Z values.
   void Set (
      double ix,
      double iy,
      double iz
      ) { x = ix; y = iy; z = iz; }

   void SetZ (
      double p_z
      ) { z = p_z; }

   void Shift (
      const DPOINT3D& value
      ) { DPOINT2D::Shift(value); z += value.z; }

   void Shift (
      const double xval,
      const double yval,
      const double zval
      ) { DPOINT2D::Shift(xval, yval); z += zval; }

   void SwapBytes (
      ) { ::SwapBytes(x); ::SwapBytes(y); ::SwapBytes(z); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(24);
   #endif
   };

inline int IniRead (INIHANDLE hdl, const char *group, const char *field, DPOINT3D& value) { return (_iniRead(hdl,group,field,INITYPE_DPOINT3D,&value,1)); }

inline int IniRead (INIHANDLE hdl, const char *group, const char *field, DPOINT3D& value, const DPOINT3D& dft) { value = dft; return (IniRead(hdl,group,field,value)); }

inline int IniWrite (INIHANDLE hdl, const char *group, const char *field, const DPOINT3D& value) { return (_iniWrite(hdl,group,field,INITYPE_DPOINT3D,&value,1)); }


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

struct FPOINT3DH {

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

   FPOINT3DH (
      ) : x(0.0F), y(0.0F), z(0.0F), w(1.0F) { }

   FPOINT3DH (
      const float dx,
      const float dy,
      const float dz,
      const float dw = 1.0F
      ) : x(dx), y(dy), z(dz), w(dw) { }

   FPOINT3DH (
      const FPOINT3D& p
      ) : x(p.x), y(p.y), z(p.z), w(1.0F) { }

   FPOINT3DH& operator= (
      const FPOINT3D& rhs
      ) { x = rhs.x; y = rhs.y; z = rhs.z; w = 1.0F; return (*this); }

   inline FPOINT3DH& operator= (
      const DPOINT3DH& rhs
      );

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

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

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

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

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

   FPOINT3DH operator+= (
      const FPOINT3DH& rhs
      ) { x += rhs.x; y += rhs.y; z += rhs.z; w += rhs.w; return (*this); }

   FPOINT3DH operator-= (
      const FPOINT3DH& rhs
      ) { x -= rhs.x; y -= rhs.y; z -= rhs.z; w -= rhs.w; return (*this); }

   FPOINT3DH operator*= (
      const float rhs
      ) { x *= rhs; y *= rhs; z *= rhs; w *= rhs; return (*this); }

   FPOINT3DH operator/= (
      const float rhs
      ) { x /= rhs; y /= rhs; z /= rhs; w /= rhs; return (*this); }

   bool Get3D (
      FPOINT3D& point
      ) {
      if (w == 0.0F) return false;
      point.x = x / w;
      point.y = y / w;
      point.z = z / w;
      return true;
      }

   bool Project (
      ) {
      if (w == 0.0F) return false;
      x /= w;
      y /= w;
      z /= w;
      w = 1.0F;
      return true;
      }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(16);
   #endif
   };


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

struct DPOINT3DH {

   double x;
   double y;
   double z;
   double w;

   DPOINT3DH (
      ) : x(0.0), y(0.0), z(0.0), w(1.0) { }

   DPOINT3DH (
      const double dx,
      const double dy,
      const double dz,
      const double dw = 1.0
      ) : x(dx), y(dy), z(dz), w(dw) { }

   DPOINT3DH (
      const DPOINT3D& p
      ) : x(p.x), y(p.y), z(p.z), w(1.0) { }

   DPOINT3DH& operator= (
      const DPOINT3D& rhs
      ) { x = rhs.x; y = rhs.y; z = rhs.z; w = 1.0; return (*this); }

   DPOINT3DH& operator= (
      const FPOINT3DH& rhs
      ) { x = rhs.x; y = rhs.y; z = rhs.z; w = rhs.w; return (*this); }

   DPOINT3DH operator- (
      ) const { return (DPOINT3DH(-x,-y,-z,-w)); }

   DPOINT3DH operator+ (
      const DPOINT3DH& rhs
      ) const { return (DPOINT3DH(x+rhs.x,y+rhs.y,z+rhs.z,w+rhs.w)); }

   DPOINT3DH operator- (
      const DPOINT3DH& rhs
      ) const { return (DPOINT3DH(x-rhs.x,y-rhs.y,z-rhs.z,w-rhs.w)); }

   DPOINT3DH operator* (
      const double rhs
      ) const { return (DPOINT3DH(x*rhs,y*rhs,z*rhs,w*rhs)); }

   DPOINT3DH operator/ (
      const double rhs
      ) const { return (DPOINT3DH(x/rhs,y/rhs,z/rhs,w/rhs)); }

   DPOINT3DH operator+= (
      const DPOINT3DH& rhs
      ) { x += rhs.x; y += rhs.y; z += rhs.z; w += rhs.w; return (*this); }

   DPOINT3DH operator-= (
      const DPOINT3DH& rhs
      ) { x -= rhs.x; y -= rhs.y; z -= rhs.z; w -= rhs.w; return (*this); }

   DPOINT3DH operator*= (
      const double rhs
      ) { x *= rhs; y *= rhs; z *= rhs; w *= rhs; return (*this); }

   DPOINT3DH operator/= (
      const double rhs
      ) { x /= rhs; y /= rhs; z /= rhs; w /= rhs; return (*this); }

   bool Get3D (
      DPOINT3D& point
      ) {
      if (w == 0.0) return false;
      point.x = x / w;
      point.y = y / w;
      point.z = z / w;
      return true;
      }

   bool Project (
      ) {
      if (w == 0.0) return false;
      x /= w;
      y /= w;
      z /= w;
      w = 1.0;
      return true;
      }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   CHECKSIZE(32);
   #endif
   };


inline bool operator== (
   const DPOINT3D& lhs, 
   const DPOINT3D& rhs
   ) {
   return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
   }

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

inline bool operator< (
   const DPOINT3D& lhs,
   const DPOINT3D& rhs
   ) {
   return (lhs.x < rhs.x || (lhs.x == rhs.x && lhs.y < rhs.y) || (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z < rhs.z));
   }

inline bool operator> (
   const DPOINT3D& lhs, 
   const DPOINT3D& rhs
   ) {
   return (lhs.x > rhs.x || (lhs.x == rhs.x && lhs.y > rhs.y) || (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z > rhs.z));
   }

inline bool operator<= (
   const DPOINT3D& lhs, 
   const DPOINT3D& rhs
   ) {
   return (lhs == rhs || lhs < rhs);
   }

inline bool operator>= (  
   const DPOINT3D& lhs, 
   const DPOINT3D& rhs
   ) {
   return (lhs == rhs || lhs > rhs);
   }

inline void SwapBytes (
   DPOINT3D& pt
   ) {
   pt.SwapBytes();
   }


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

#ifndef GENERATING_DOXYGEN_OUTPUT

inline LPOINT2D::LPOINT2D (
   const DPOINT2D& pt
   ) : x(static_cast<INT32>(pt.x)), y(static_cast<INT32>(pt.y)) {
   }

inline LPOINT2D& LPOINT2D::operator= (
   const DPOINT2D& pt
   ) {
   x = static_cast<INT32>(pt.x);
   y = static_cast<INT32>(pt.y);
   return (*this);
   }

inline DPOINT2D_OLD& DPOINT2D_OLD::operator= (
   const DPOINT2D& rhs
   ) {
   x = rhs.x;
   y = rhs.y;
   return (*this);
   }

inline DPOINT3D_OLD& DPOINT3D_OLD::operator= (
   const DPOINT3D& rhs
   ) {
   x = rhs.x;
   y = rhs.y;
   z = rhs.z;
   return (*this);
   }

inline FPOINT2D& FPOINT2D::operator= (
   const DPOINT2D& rhs
   ) {
   x = static_cast<float>(rhs.x);
   y = static_cast<float>(rhs.y);
   return (*this);
   }

inline FPOINT3D& FPOINT3D::operator= (
   const DPOINT3D& rhs
   ) {
   x = static_cast<float>(rhs.x);
   y = static_cast<float>(rhs.y);
   z = static_cast<float>(rhs.z);
   return (*this);
   }

inline FPOINT3DH& FPOINT3DH::operator= (
   const DPOINT3DH& rhs
   ) {
   x = static_cast<float>(rhs.x);
   y = static_cast<float>(rhs.y);
   z = static_cast<float>(rhs.z);
   w = static_cast<float>(rhs.w);
   return (*this);
   }

#endif 

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

#endif   

---