mi32/rect.h

Go to the documentation of this file.

#ifndef  INC_MI32_RECT_H
#define  INC_MI32_RECT_H


#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

#ifdef ALLOW_NAMESPACES
   #include <limits>
   #include <cmath>
#else
   #include <limits.h>
   #include <float.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT

#ifdef GEOMDLL
   #define GEOMLIBEXPORT MI_DLLEXPORT
   #define GEOMLIBCLASSEXPORT MI_DLLCLASSEXPORT
#else
   #define GEOMLIBEXPORT MI_DLLIMPORT
   #define GEOMLIBCLASSEXPORT MI_DLLCLASSIMPORT
#endif

GEOMLIBEXPORT void LRect2DGetCorners (const LRECT2D& rect, LPOINT2D *pts, bool ClosePoly, bool OrientCCW);
GEOMLIBEXPORT bool DRect2DComputeEdgePoint (const DRECT2D& rect, const DPOINT2D& OutsidePt, DPOINT2D& EdgePt);
GEOMLIBEXPORT void DRect2DGetCorners (const DRECT2D& rect, DPOINT2D *pts, bool ClosePoly, bool OrientCCW);
GEOMLIBEXPORT void DRect2DGetCorners (const DRECT2D& rect, DPOINT3D *pts, bool ClosePoly, bool OrientCCW);
GEOMLIBEXPORT double DRect2DGetDistance (const DRECT2D& trect, const DRECT2D& rect);
GEOMLIBEXPORT double DRect2DGetMaxDistance (const DRECT2D& trect, const DRECT2D& rect);
GEOMLIBEXPORT double DRect2DGetMaxDistanceSquared (const DRECT2D& trect, const DRECT2D& rect);
GEOMLIBEXPORT bool DRect2DIsEquivalentTo (const DRECT2D& trect, const DRECT2D& rect, double thresold);

#endif      //GENERATING_DOXYGEN_OUTPUT

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

struct WRECT2D {
   INT16 xinit;                     
   INT16 yinit;                     
   INT16 xlast;                     
   INT16 ylast;                     

   WRECT2D (
      ): xinit(INT16_MAX), yinit(INT16_MAX), xlast(INT16_MIN), ylast(INT16_MIN) { }

   WRECT2D (
      INT16 xi,
      INT16 yi,
      INT16 xl,
      INT16 yl
      ) : xinit(xi), yinit(yi), xlast(xl), ylast(yl) { }

   bool Contains (
      INT16 x,
      INT16 y
      ) const { return (x >= xinit && x <= xlast && y >= yinit && y <= ylast); }

   bool Contains (
      const WPOINT2D& pt
      ) const { return (pt.x >= xinit && pt.x <= xlast && pt.y >= yinit && pt.y <= ylast); }

   bool Contains (
      const WRECT2D& rhs
      ) const { return (rhs.xinit >= xinit && rhs.xlast <= xlast && rhs.yinit >= yinit && rhs.ylast <= ylast); }

   void Expand (
      const INT16 value
      ) { xinit -= value; yinit -= value; xlast += value; ylast += value; }
   
   void Expand (
      const INT16 xval,
      const INT16 yval
      ) { xinit -= xval; yinit -= yval; xlast += xval; ylast += yval; }

   void Extend (
      const INT16 xval,
      const INT16 yval
      ) {
      if (xval < xinit) xinit = xval;
      if (yval < yinit) yinit = yval;
      if (xval > xlast) xlast = xval;
      if (yval > ylast) ylast = yval;
      }

   UINT16 GetHeight (
      ) const { return (ylast - yinit + 1); }

   UINT16 GetWidth (
      ) const { return (xlast - xinit + 1); }

   bool IsNonEmpty (
      ) const { return (xinit < xlast && yinit < ylast); }

   bool IsValid (
      ) const { return (xinit <= xlast && yinit <= ylast); }

   bool Overlaps (
      const WRECT2D& rhs
      ) const {
      return (!(rhs.xlast < xinit || rhs.xinit > xlast || rhs.ylast < yinit || rhs.yinit > ylast));
      }
   
   void Set (
      INT16 x1,
      INT16 y1,
      INT16 x2,
      INT16 y2
      ) { xinit = x1; yinit = y1; xlast = x2; ylast = y2; }

   void SetInvalid (
      ) { xinit = yinit = INT16_MAX; xlast = ylast = INT16_MIN; }

   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   // Make compiler validate structure size.
   CHECKSIZE(8);
   #endif
   };

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

struct LRECT2D {

   INT32 xinit;                     
   INT32 yinit;                     
   INT32 xlast;                     
   INT32 ylast;                     

   LRECT2D (
      ): xinit(INT32_MAX), yinit(INT32_MAX), xlast(INT32_MIN), ylast(INT32_MIN) { }

   LRECT2D (
      INT32 xsize,
      INT32 ysize
      ) : xinit(0), yinit(0), xlast(xsize-1), ylast(ysize-1) { }

   LRECT2D (
      const LPOINT2D pt
      ) : xinit(pt.x), yinit(pt.y), xlast(pt.x), ylast(pt.y) { }

   LRECT2D (
      INT32 xi,
      INT32 yi,
      INT32 xl,
      INT32 yl
      ) : xinit(xi), yinit(yi), xlast(xl), ylast(yl) { }

   bool Contains (
      INT32 x,
      INT32 y
      ) const { return (x >= xinit && x <= xlast && y >= yinit && y <= ylast); }

   bool Contains (
      const LPOINT2D& pt
      ) const { return (pt.x >= xinit && pt.x <= xlast && pt.y >= yinit && pt.y <= ylast); }

   bool Contains (
      const LRECT2D& rhs
      ) const { return (rhs.xinit >= xinit && rhs.xlast <= xlast && rhs.yinit >= yinit && rhs.ylast <= ylast); }

   void Expand (
      const INT32 value
      ) { xinit -= value; yinit -= value; xlast += value; ylast += value; }
   
   void Expand (
      const INT32 xval,
      const INT32 yval
      ) { xinit -= xval; yinit -= yval; xlast += xval; ylast += yval; }

   void Extend (
      const LRECT2D& rect
      ) {
      if (rect.xinit < xinit) xinit = rect.xinit;
      if (rect.yinit < yinit) yinit = rect.yinit;
      if (rect.xlast > xlast) xlast = rect.xlast;
      if (rect.ylast > ylast) ylast = rect.ylast;
      }

   void Extend (
      const LPOINT2D& pt
      ) {
      if (pt.x < xinit) xinit = pt.x;
      if (pt.x > xlast) xlast = pt.x;
      if (pt.y < yinit) yinit = pt.y;
      if (pt.y > ylast) ylast = pt.y;
      }

   void Extend (
      const INT32 xval,
      const INT32 yval
      ) {
      if (xval < xinit) xinit = xval;
      if (yval < yinit) yinit = yval;
      if (xval > xlast) xlast = xval;
      if (yval > ylast) ylast = yval;
      }

   INT32 GetArea (
      ) const { return (GetWidth() * GetHeight()); }

   void GetBottomLeft (
      LPOINT2D& ret
      ) const { ret.x = xinit; ret.y = yinit; }

   void GetBottomRight (
      LPOINT2D& ret
      ) const { ret.x = xlast; ret.y = yinit; }

   DPOINT2D GetCenter (
      ) const { return (DPOINT2D((xlast + xinit)/2.0, (ylast + yinit)/2.0)); }

   void GetCenter (
      DPOINT2D& ret
      ) const { ret.x = (xinit + xlast) / 2.0; ret.y = (yinit + ylast) / 2.0; }

   void GetCorners (
      LPOINT2D *corners,               
      bool ClosePoly = false,          
      bool OrientCCW = false           
      ) const { LRect2DGetCorners(*this, corners, ClosePoly, OrientCCW); }

   int GetDimension (
      ) const {
      int count(0);
      if (xinit < xlast) count ++;
      if (yinit < ylast) count ++;
      return (count);
      }

   UINT32 GetHeight (
      ) const { return (ylast - yinit + 1); }

   LPOINT2D GetMaxXMaxY (
      ) const { return (LPOINT2D(xlast,ylast)); }

   LPOINT2D GetMaxXMinY (
      ) const { return (LPOINT2D(xlast,yinit)); }

   LPOINT2D GetMinXMaxY (
      ) const { return (LPOINT2D(xinit,ylast)); }

   LPOINT2D GetMinXMinY (
      ) const { return (LPOINT2D(xinit,yinit)); }

   void GetSize (
      LPOINT2D& ret
      ) const { ret.x = xlast - xinit; ret.y = ylast - yinit; }

   void GetTopLeft (
      LPOINT2D& ret
      ) const { ret.x = xinit; ret.y = ylast; }

   void GetTopRight (
      LPOINT2D& ret
      ) const { ret.x = xlast; ret.y = ylast; }

   UINT32 GetWidth (
      ) const { return (xlast - xinit + 1); }

   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) { return (_iniRead(IniHandle,IniGroup,IniName,INITYPE_INT32,this,4) == 4); }

   void IniWrite (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) const { _iniWrite(IniHandle,IniGroup,IniName,INITYPE_INT32,this,4); }

   void Intersect (
      const LRECT2D& rect
      ) {
      if (rect.IsValid()) {
         if (rect.xinit > xinit) xinit = rect.xinit;
         if (rect.yinit > yinit) yinit = rect.yinit;
         if (rect.xlast < xlast) xlast = rect.xlast;
         if (rect.ylast < ylast) ylast = rect.ylast;
         }
      else {
         *this = rect;
         }
      return;
      }

   bool IsNonEmpty (
      ) const { return (xinit < xlast && yinit < ylast); }

   bool IsValid (
      ) const { return (xinit <= xlast && yinit <= ylast); }

   void Limit (
      LPOINT2D& point
      ) const {
      if (point.x < xinit) point.x = xinit; else if (point.x > xlast) point.x = xlast;
      if (point.y < yinit) point.y = yinit; else if (point.y > ylast) point.y = ylast;
      }

   void Limit (
      DPOINT2D& point
      ) const {
      if (point.x < xinit) point.x = xinit; else if (point.x > xlast) point.x = xlast;
      if (point.y < yinit) point.y = yinit; else if (point.y > ylast) point.y = ylast;
      }

   bool Overlaps (
      const LRECT2D& rhs
      ) const {
      return (!(rhs.xlast < xinit || rhs.xinit > xlast || rhs.ylast < yinit || rhs.yinit > ylast));
      }
   
   void Set (
      INT32 x1,
      INT32 y1,
      INT32 x2,
      INT32 y2
      ) { xinit = x1; yinit = y1; xlast = x2; ylast = y2; }

   void SetInvalid (
      ) { xinit = yinit = INT32_MAX; xlast = ylast = INT32_MIN; }

   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   // Make compiler validate structure size.
   CHECKSIZE(16);
   #endif
   };

inline bool operator== (
   const LRECT2D& lhs,
   const LRECT2D& rhs
   ) {
   return (lhs.xinit == rhs.xinit && lhs.xlast == rhs.xlast && lhs.yinit == rhs.yinit && lhs.ylast == rhs.ylast);
   }

inline bool operator!= (
   const LRECT2D& lhs,
   const LRECT2D& rhs
   ) {
   return (!operator==(lhs,rhs));
   }


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

struct LRECT3D : public LRECT2D {

   INT32 zinit;
   INT32 zlast;

   LRECT3D (
      ) : LRECT2D(), zinit(INT32_MAX), zlast(INT32_MIN) { }

   LRECT3D (
      const LPOINT3D& pt
      ) : LRECT2D(pt), zinit(pt.z), zlast(pt.z) { }

   LRECT3D (
      const LPOINT3D& pt1,
      const LPOINT3D& pt2
      ) {
      if (pt1.x < pt2.x) {
         xinit = pt1.x;
         xlast = pt2.x;
         }
      else {
         xinit = pt2.x;
         xlast = pt1.x;
         }
      if (pt1.y < pt2.y) {
         yinit = pt1.y;
         ylast = pt2.y;
         }
      else {
         yinit = pt2.y;
         ylast = pt1.y;
         }
      if (pt1.z < pt2.z) {
         zinit = pt1.z;
         zlast = pt2.z;
         }
      else {
         zinit = pt2.z;
         zlast = pt1.z;
         }
      }

   LRECT3D (
      const LRECT2D& rect
      ) : LRECT2D(rect), zinit(0), zlast(0) { }

   LRECT3D (
      const LRECT2D& rect,
      INT32 zmin,
      INT32 zmax
      ) : LRECT2D(rect), zinit(zmin), zlast(zmax) { }

   LRECT3D& operator= (
      const LPOINT3D& pt
      ) {
      xinit = xlast = pt.x;
      yinit = ylast = pt.y;
      zinit = zlast = pt.z;
      return (*this);
      }

   bool Contains (
      const LPOINT3D& pt
      ) const { return (LRECT2D::Contains(pt) && pt.z >= zinit && pt.z <= zlast); }
   
   bool Contains (
      const LRECT3D& rhs
      ) const { return (LRECT2D::Contains(rhs) && rhs.zinit >= zinit && rhs.zlast <= zlast); }

   void Expand (
      const INT32 value
      ) {
      LRECT2D::Expand(value);
      zinit -= value; zlast += value;
      return;
      }

   void Expand (
      const INT32 xval,
      const INT32 yval
      ) { LRECT2D::Expand(xval, yval); }

   void Extend (
      const INT32 xval,
      const INT32 yval
      ) { LRECT2D::Extend(xval, yval); }

   void Extend (
      const INT32 xval,
      const INT32 yval,
      const INT32 zval
      ) {
      LRECT2D::Extend(xval, yval);
      if (zval < zinit) zinit = zval;
      if (zval > zlast) zlast = zval;
      return;
      }

   void Extend (
      const LRECT3D& rect
      ) {
      LRECT2D::Extend(rect);
      if (rect.zinit < zinit) zinit = rect.zinit;
      if (rect.zlast > zlast) zlast = rect.zlast;
      return;
      }

   void Extend (
      const LPOINT2D& pt
      ) { LRECT2D::Extend(pt); }

   void Extend (
      const LPOINT3D& pt
      ) {
      LRECT2D::Extend(pt);
      if (pt.z < zinit) zinit = pt.z;
      if (pt.z > zlast) zlast = pt.z;
      return;
      }

   DPOINT3D GetCenter (
      ) const { return (DPOINT3D((xinit+xlast)/2.0,(yinit+ylast)/2.0,(zinit+zlast)/2.0)); }

   void GetCenter (
      DPOINT3D& ret
      ) const {
      ret.x = (xinit + xlast) / 2.0;
      ret.y = (yinit + ylast) / 2.0;
      ret.z = (zinit + zlast) / 2.0;
      }

   INT32 GetDepth (
      ) const { return (zlast - zinit); }

   int GetDimension (
      ) const {
      int count(LRECT2D::GetDimension());
      if (zinit < zlast) count ++;
      return (count);
      }

   void GetMaximum (
      LPOINT3D& maximum
      ) const { maximum.x = xlast; maximum.y = ylast; maximum.z = zlast; }

   void GetMinimum (
      LPOINT3D& minimum
      ) const { minimum.x = xinit; minimum.y = yinit; minimum.z = zinit; }

   void GetSize (
      LPOINT3D& ret
      ) const {
      ret.x = xlast - xinit;
      ret.y = ylast - yinit;
      ret.z = zlast - zinit;
      }

   INT32 GetVolume (
      ) const { return (LRECT2D::GetArea() * (zlast - zinit)); }

   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) { return (_iniRead(IniHandle,IniGroup,IniName,INITYPE_INT32,this,6) == 6); }

   void IniWrite (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) const { _iniWrite(IniHandle,IniGroup,IniName,INITYPE_INT32,this,6); }

   void Intersect (
      const LRECT3D& rect
      ) {
      if (rect.IsValid()) {
         LRECT2D::Intersect(rect);
         if (rect.zinit > zinit) zinit = rect.zinit;
         if (rect.zlast < zlast) zlast = rect.zlast;
         }
      else {
         *this = rect;
         }
      return;
      }
   
   bool IsValid (
      ) const { return (LRECT2D::IsValid() && zinit <= zlast); }

   bool Overlaps (
      const LRECT3D& rhs
      ) const { return (LRECT2D::Overlaps(rhs) && !(rhs.zlast < zinit || rhs.zinit > zlast)); }

   void Set (
      INT32 x1,
      INT32 y1,
      INT32 x2,
      INT32 y2
      ) { xinit = x1; yinit = y1; xlast = x2; ylast = y2; zinit = zlast = 0; }

   void Set (
      INT32 xmin,
      INT32 ymin,
      INT32 zmin,
      INT32 xmax,
      INT32 ymax,
      INT32 zmax
      ) { xinit = xmin; yinit = ymin; zinit = zmin; xlast = xmax; ylast = ymax; zlast = zmax; }

   void SetInvalid (
      ) { LRECT2D::SetInvalid(); zinit = INT32_MAX; zlast = INT32_MIN; }

   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); ::SwapBytes(zinit); ::SwapBytes(zlast); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   // Make compiler validate structure size.
   CHECKSIZE(24);
   #endif
   };

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

struct DRECT2D {
   
   double xinit;                    
   double yinit;                    
   double xlast;                    
   double ylast;                    

   DRECT2D (
      ) : xinit(DBL_MAX), yinit(DBL_MAX), xlast(-DBL_MAX), ylast(-DBL_MAX) {
      }

   DRECT2D (
      const FPOINT2D& pt
      ) : xinit(pt.x), yinit(pt.y), xlast(pt.x), ylast(pt.y) { }

   DRECT2D (
      const DPOINT2D& pt
      ) : xinit(pt.x), yinit(pt.y), xlast(pt.x), ylast(pt.y) { }

   DRECT2D (
      const DPOINT2D& pt1,
      const DPOINT2D& pt2
      ) { SetCorners(pt1,pt2); }

   DRECT2D (
      double xi,
      double yi,
      double xl,
      double yl
      ) : xinit(xi), yinit(yi), xlast(xl), ylast(yl) { }

   DRECT2D (
      const LRECT2D& rect
      ) : xinit(rect.xinit), yinit(rect.yinit), xlast(rect.xlast), ylast(rect.ylast) { }

   DRECT2D& operator= (
      const DPOINT2D& pt
      ) { xinit = xlast = pt.x; yinit = ylast = pt.y; return (*this); }

   DRECT2D& operator= (
      const LRECT2D& rhs
      ) { xinit = rhs.xinit; yinit = rhs.yinit; xlast = rhs.xlast; ylast = rhs.ylast; return (*this); }

   void AlignToMultiple (
      double AlignSize,
      double RoundTolerance = .000001
      ) {
      xinit = floor(xinit / AlignSize + RoundTolerance) * AlignSize;
      yinit = floor(yinit / AlignSize + RoundTolerance) * AlignSize;
      xlast = ceil(xlast / AlignSize - RoundTolerance) * AlignSize;
      ylast = ceil(ylast / AlignSize - RoundTolerance) * AlignSize;
      return;
      }

   void ClipTo (
      const DRECT2D& rect
      ) {
      if (xinit < rect.xinit) xinit = rect.xinit;
      if (yinit < rect.yinit) yinit = rect.yinit;
      if (xlast > rect.xlast) xlast = rect.xlast;
      if (ylast > rect.ylast) ylast = rect.ylast;
      return;
      }

   bool ComputeEdgePoint (
      const DPOINT2D& OutsidePt,       
      DPOINT2D& EdgePt                 
      ) const { return (DRect2DComputeEdgePoint(*this, OutsidePt, EdgePt)); }

   bool Contains (
      double x,
      double y
      ) const { return (x >= xinit && x <= xlast && y >= yinit && y <= ylast); }

   bool Contains (
      const DPOINT2D& pt
      ) const { return (pt.x >= xinit && pt.x <= xlast && pt.y >= yinit && pt.y <= ylast); }

   bool Contains (
      const DRECT2D& rhs
      ) const { return (rhs.xinit >= xinit && rhs.xlast <= xlast && rhs.yinit >= yinit && rhs.ylast <= ylast); }

   void Expand (
      const double value
      ) { xinit -= value; yinit -= value; xlast += value; ylast += value; }

   void Expand (
      const double xval,
      const double yval
      ) { xinit -= xval; yinit -= yval; xlast += xval; ylast += yval; }

   void Extend (
      const double xval,
      const double yval
      ) {
      if (xval < xinit) xinit = xval;
      if (yval < yinit) yinit = yval;
      if (xval > xlast) xlast = xval;
      if (yval > ylast) ylast = yval;
      return;
      }

   void Extend (
      const DRECT2D& rect
      ) {
      if (rect.xinit < xinit) xinit = rect.xinit;
      if (rect.yinit < yinit) yinit = rect.yinit;
      if (rect.xlast > xlast) xlast = rect.xlast;
      if (rect.ylast > ylast) ylast = rect.ylast;
      return;
      }

   void Extend (
      const DPOINT2D& pt
      ) {
      if (pt.x < xinit) xinit = pt.x;
      if (pt.x > xlast) xlast = pt.x;
      if (pt.y < yinit) yinit = pt.y;
      if (pt.y > ylast) ylast = pt.y;
      return;
      }

   double GetArea (
      ) const { return ((xlast - xinit) * (ylast - yinit)); }

   void GetBottomLeft (
      DPOINT2D& ret
      ) const { ret.x = xinit; ret.y = yinit; }

   void GetBottomRight (
      DPOINT2D& ret
      ) const { ret.x = xlast; ret.y = yinit; }

   DPOINT2D GetCenter (
      ) const { return (DPOINT2D((xlast + xinit)/2.0, (ylast + yinit)/2.0)); }

   void GetCenter (
      DPOINT2D& ret
      ) const { ret.x = (xinit + xlast) / 2.0; ret.y = (yinit + ylast) / 2.0; }

   void GetCorners (
      DPOINT2D *corners,               
      bool ClosePoly = false,          
      bool OrientCCW = false           
      ) const { DRect2DGetCorners(*this, corners, ClosePoly, OrientCCW); }

   void GetCorners (
      DPOINT3D *corners,               
      bool ClosePoly = false,          
      bool OrientCCW = false           
      ) const { DRect2DGetCorners(*this, corners, ClosePoly, OrientCCW); }

   int GetDimension (
      ) const {
      int count(0);
      if (xinit < xlast) count ++;
      if (yinit < ylast) count ++;
      return (count);
      }

   double GetDistance (
      const DRECT2D& rect
      ) const { return (DRect2DGetDistance(*this, rect)); }

   double GetHeight (
      ) const { return (ylast - yinit); }

   double GetMaxDistance (
      const DRECT2D& rect
      ) const { return (DRect2DGetMaxDistance(*this, rect)); }

   double GetMaxDistanceSquared (
      const DRECT2D& rect
      ) const { return (DRect2DGetMaxDistanceSquared(*this, rect)); }

   DEPRECATED void GetRect (
      LRECT2D& rect
      ) const { GetRectRoundNoLimit(rect); }

   void GetRectRoundLimited (
      LRECT2D& rect
      ) const {
      rect.xinit = static_cast<INT32>(FAST_ROUND_LIMITED(xinit));
      rect.yinit = static_cast<INT32>(FAST_ROUND_LIMITED(yinit));
      rect.xlast = static_cast<INT32>(FAST_ROUND_LIMITED(xlast));
      rect.ylast = static_cast<INT32>(FAST_ROUND_LIMITED(ylast));
      }

   void GetRectRoundNoLimit (
      LRECT2D& rect
      ) const {
      rect.xinit = static_cast<INT32>(FAST_ROUND_NOLIMIT(xinit));
      rect.yinit = static_cast<INT32>(FAST_ROUND_NOLIMIT(yinit));
      rect.xlast = static_cast<INT32>(FAST_ROUND_NOLIMIT(xlast));
      rect.ylast = static_cast<INT32>(FAST_ROUND_NOLIMIT(ylast));
      }

   void GetRectRoundPositive (
      LRECT2D& rect
      ) const {
      rect.xinit = static_cast<INT32>(FAST_ROUND_POSITIVE(xinit));
      rect.yinit = static_cast<INT32>(FAST_ROUND_POSITIVE(yinit));
      rect.xlast = static_cast<INT32>(FAST_ROUND_POSITIVE(xlast));
      rect.ylast = static_cast<INT32>(FAST_ROUND_POSITIVE(ylast));
      }

   void GetRectTruncate (
      LRECT2D& rect
      ) const {
      rect.xinit = static_cast<INT32>(FAST_TRUNCATE(xinit));
      rect.yinit = static_cast<INT32>(FAST_TRUNCATE(yinit));
      rect.xlast = static_cast<INT32>(FAST_TRUNCATE(xlast));
      rect.ylast = static_cast<INT32>(FAST_TRUNCATE(ylast));
      }

   void GetSize (
      DPOINT2D& ret
      ) const { ret.x = xlast - xinit; ret.y = ylast - yinit; }

   void GetTopLeft (
      DPOINT2D& ret
      ) const { ret.x = xinit; ret.y = ylast; }

   void GetTopRight (
      DPOINT2D& ret
      ) const { ret.x = xlast; ret.y = ylast; }

   double GetWidth (
      ) const { return (xlast - xinit); }

   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) { return (_iniRead(IniHandle,IniGroup,IniName,INITYPE_DRECT2D,this,1) == 1); }

   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName,
      const DRECT2D& dft
      ) { if (IniRead(IniHandle,IniGroup,IniName)) return (true); else { *this = dft; return (false); } }

   void IniWrite (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) const { _iniWrite(IniHandle,IniGroup,IniName,INITYPE_DRECT2D,this,1); }

   void Intersect (
      const DRECT2D& rect
      ) {
      if (rect.IsValid()) {
         if (rect.xinit > xinit) xinit = rect.xinit;
         if (rect.yinit > yinit) yinit = rect.yinit;
         if (rect.xlast < xlast) xlast = rect.xlast;
         if (rect.ylast < ylast) ylast = rect.ylast;
         }
      else {
         *this = rect;
         }
      }

   bool Intersects (
      const DRECT2D& rhs
      ) const { return (rhs.xlast > xinit && rhs.xinit < xlast && rhs.ylast > yinit && rhs.yinit < ylast); }

   bool IsEquivalentTo (
      const DRECT2D& rhs,
      double threshold = 0.0        
      ) const { return (DRect2DIsEquivalentTo(*this, rhs, threshold)); }

   bool IsNonEmpty (
      ) const { return (xinit < xlast && yinit < ylast); }

   bool IsValid (
      ) const { return (xinit <= xlast && yinit <= ylast); }

   void Limit (
      DPOINT2D& point
      ) const {
      if (point.x < xinit) point.x = xinit; else if (point.x > xlast) point.x = xlast;
      if (point.y < yinit) point.y = yinit; else if (point.y > ylast) point.y = ylast;
      }

   bool Overlaps (
      const DRECT2D& rhs
      ) const { return (!(rhs.xlast < xinit || rhs.xinit > xlast || rhs.ylast < yinit || rhs.yinit > ylast)); }

   void Set (
      double x1,
      double y1,
      double x2,
      double y2
      ) { xinit = x1; yinit = y1; xlast = x2; ylast = y2; }

   void SetCorners (
      const DPOINT2D pt1,
      const DPOINT2D pt2
      ) {
      if (pt1.x < pt2.x) { xinit = pt1.x; xlast = pt2.x; }
      else { xinit = pt2.x; xlast = pt1.x; }
      if (pt1.y < pt2.y) { yinit = pt1.y; ylast = pt2.y; }
      else { yinit = pt2.y; ylast = pt1.y; }
      }

   void SetInvalid (
      ) { xinit = yinit = DBL_MAX; xlast = ylast = -DBL_MAX; }

   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   // Make compiler validate structure size.
   CHECKSIZE(32);
   #endif
   };

inline bool operator== (
   const DRECT2D& lhs,
   const DRECT2D& rhs
   ) {
   return (lhs.xinit == rhs.xinit && lhs.xlast == rhs.xlast && lhs.yinit == rhs.yinit && lhs.ylast == rhs.ylast);
   }

inline bool operator!= (
   const DRECT2D& lhs,
   const DRECT2D& rhs
   ) {
   return (!operator==(lhs,rhs));
   }

inline void SwapBytes (
   DRECT2D& rect
   ) {
   rect.SwapBytes();
   }

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

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

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


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

struct DRECT3D : public DRECT2D {
   
   double zinit;
   double zlast;

   DRECT3D (
      ) : DRECT2D(), zinit(DBL_MAX), zlast(-DBL_MAX) { }

   DRECT3D (
      const FPOINT3D& pt
      ) : DRECT2D(pt), zinit(pt.z), zlast(pt.z) { }

   DRECT3D (
      const DPOINT3D& pt
      ) : DRECT2D(pt), zinit(pt.z), zlast(pt.z) { }

   DRECT3D (
      const DPOINT3D& pt1,
      const DPOINT3D& pt2
      ) {
      if (pt1.x < pt2.x) {
         xinit = pt1.x;
         xlast = pt2.x;
         }
      else {
         xinit = pt2.x;
         xlast = pt1.x;
         }
      if (pt1.y < pt2.y) {
         yinit = pt1.y;
         ylast = pt2.y;
         }
      else {
         yinit = pt2.y;
         ylast = pt1.y;
         }
      if (pt1.z < pt2.z) {
         zinit = pt1.z;
         zlast = pt2.z;
         }
      else {
         zinit = pt2.z;
         zlast = pt1.z;
         }
      }

   DRECT3D (
      const DRECT2D& rect
      ) : DRECT2D(rect), zinit(0.0), zlast(0.0) { }

   DRECT3D (
      const DRECT2D& rect,
      double zmin,
      double zmax
      ) : DRECT2D(rect), zinit(zmin), zlast(zmax) { }

   DRECT3D& operator= (
      const DPOINT3D& pt
      ) {
      xinit = xlast = pt.x;
      yinit = ylast = pt.y;
      zinit = zlast = pt.z;
      return (*this);
      }

   bool Contains (
      const DPOINT3D& pt
      ) const { return (DRECT2D::Contains(pt) && pt.z >= zinit && pt.z <= zlast); }
   
   bool Contains (
      const DRECT3D& rhs
      ) const { return (DRECT2D::Contains(rhs) && rhs.zinit >= zinit && rhs.zlast <= zlast); }

   void Expand (
      const double value
      ) {
      DRECT2D::Expand(value);
      zinit -= value; zlast += value;
      return;
      }

   void Expand (
      const double xval,
      const double yval
      ) { DRECT2D::Expand(xval, yval); }

   void Extend (
      const double xval,
      const double yval
      ) { DRECT2D::Extend(xval, yval); }

   void Extend (
      const double xval,
      const double yval,
      const double zval
      ) {
      DRECT2D::Extend(xval, yval);
      if (zval < zinit) zinit = zval;
      if (zval > zlast) zlast = zval;
      return;
      }

   void Extend (
      const DRECT3D& rect
      ) {
      DRECT2D::Extend(rect);
      if (rect.zinit < zinit) zinit = rect.zinit;
      if (rect.zlast > zlast) zlast = rect.zlast;
      return;
      }

   void Extend (
      const DPOINT2D& pt
      ) { DRECT2D::Extend(pt); }

   void Extend (
      const DPOINT3D& pt
      ) {
      DRECT2D::Extend(pt);
      if (pt.z < zinit) zinit = pt.z;
      if (pt.z > zlast) zlast = pt.z;
      return;
      }

   DPOINT3D GetCenter (
      ) const { return (DPOINT3D((xinit+xlast)/2.0,(yinit+ylast)/2.0,(zinit+zlast)/2.0)); }

   void GetCenter (
      DPOINT3D& ret
      ) const {
      ret.x = (xinit + xlast) / 2.0;
      ret.y = (yinit + ylast) / 2.0;
      ret.z = (zinit + zlast) / 2.0;
      return;
      }

   double GetDepth (
      ) const { return (zlast - zinit); }

   int GetDimension (
      ) const {
      int count(DRECT2D::GetDimension());
      if (zinit < zlast) count ++;
      return (count);
      }

   void GetMaximum (
      DPOINT3D& maximum
      ) const { maximum.x = xlast; maximum.y = ylast; maximum.z = zlast; }

   void GetMinimum (
      DPOINT3D& minimum
      ) const { minimum.x = xinit; minimum.y = yinit; minimum.z = zinit; }

   void GetSize (
      DPOINT3D& ret
      ) const {
      ret.x = xlast - xinit;
      ret.y = ylast - yinit;
      ret.z = zlast - zinit;
      return;
      }

   double GetVolume (
      ) const { return (DRECT2D::GetArea() * (zlast - zinit)); }

   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) { return (_iniRead(IniHandle,IniGroup,IniName,INITYPE_Double,this,6) == 6); }

   void IniWrite (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) const { _iniWrite(IniHandle,IniGroup,IniName,INITYPE_Double,this,6); }

   void Intersect (
      const DRECT3D& rect
      ) {
      if (rect.IsValid()) {
         DRECT2D::Intersect(rect);
         if (rect.zinit > zinit) zinit = rect.zinit;
         if (rect.zlast < zlast) zlast = rect.zlast;
         }
      else {
         *this = rect;
         }
      return;
      }
   
   bool IsValid (
      ) const { return (DRECT2D::IsValid() && zinit <= zlast); }

   bool Overlaps (
      const DRECT3D& rhs
      ) const { return (DRECT2D::Overlaps(rhs) && !(rhs.zlast < zinit || rhs.zinit > zlast)); }

   void Set (
      double x1,
      double y1,
      double x2,
      double y2
      ) { xinit = x1; yinit = y1; xlast = x2; ylast = y2; zinit = zlast = 0.0; }

   void Set (
      double xmin,
      double ymin,
      double zmin,
      double xmax,
      double ymax,
      double zmax
      ) { xinit = xmin; yinit = ymin; zinit = zmin; xlast = xmax; ylast = ymax; zlast = zmax; }

   void SetInvalid (
      ) { DRECT2D::SetInvalid(); zinit = DBL_MAX; zlast = -DBL_MAX; }

   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); ::SwapBytes(zinit); ::SwapBytes(zlast); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
   // Make compiler validate structure size.
   CHECKSIZE(48);
   #endif
   };

inline bool operator== (
   const DRECT3D& lhs,
   const DRECT3D& rhs
   ) {
   return (lhs.xinit == rhs.xinit && lhs.xlast == rhs.xlast && lhs.yinit == rhs.yinit && lhs.ylast == rhs.ylast && lhs.zinit == rhs.zinit && lhs.zlast == rhs.zlast);
   }

inline bool operator!= (
   const DRECT3D& lhs,
   const DRECT3D& rhs
   ) {
   return (!operator==(lhs,rhs));
   }

inline void SwapBytes (
   DRECT3D& rect
   ) {
   rect.SwapBytes();
   }


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

#endif   

---