rect.h

Go to the documentation of this file.

/**
 * \file rect.h <mi32/rect.h>
 * \brief Definitions for 2D and 3D rectangle structures
 *
 * \if NODOC
 * $Id: rect.h_v 1.45 2004/11/16 16:53:28 dwilliss Exp $
 *
 * $Log: rect.h_v $
 * Revision 1.45  2004/11/16 16:53:28  dwilliss
 * Added a GetRectTruncate to DRECT2D
 *
 * Revision 1.44  2004/10/14 21:58:11  scowan
 * Added ctor's for 2d and 3d rect using two points.
 *
 * Revision 1.43  2004/03/02 00:24:17  scowan
 * Made non-inline functions inline to calls to exported functions.
 *
 * Revision 1.42  2003/11/28 16:45:16  scowan
 * Added is equiv to method.
 *
 * Revision 1.41  2003/11/12 13:20:00  mju
 * Add drect3d.getMinimum/Maximum.
 *
 * Revision 1.40  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.39  2003/04/15 13:34:06  mju
 * Add IniRead/Write methods.
 *
 * Revision 1.38  2003/02/21 15:19:44  mju
 * Add SwapBytes method.
 *
 * Revision 1.37  2003/02/04 20:24:31  vdronov
 * ctor for DRECTXD from FPOINTXD
 *
 * Revision 1.36  2002/12/04 16:27:47  dwilliss
 * Fixed a compiler warning
 *
 * Revision 1.35  2002/08/19 17:56:04  mju
 * Change GetArea() to do getwidth*getheight.
 *
 * Revision 1.34  2002/08/19 17:35:37  mju
 * In LRECT2D ctor init to 'empty' rectangle.
 *
 * Revision 1.33  2002/08/13 14:23:01  scowan
 * Added more distance methods.
 *
 * Revision 1.32  2002/07/02 20:17:04  scowan
 * Added get corners for 3d point array.
 *
 * Revision 1.31  2002/06/13 21:50:24  scowan
 * Added compute edge method.
 *
 * Revision 1.30  2002/01/22 18:52:36  scowan
 * Nothing.
 *
 * Revision 1.29  2001/12/11 17:44:34  scowan
 * Added swap bytes functions for rects.
 *
 * Revision 1.28  2001/09/26 17:26:09  scowan
 * Fixed equality operator.
 *
 * Revision 1.26  2001/02/07 23:01:20  scowan
 * Added 3D extend method.
 *
 * Revision 1.25  2001/01/17 14:45:37  mju
 * Add LRECT2D:Extend(x,y).
 *
 * Revision 1.24  2000/12/20 21:44:42  mju
 * Add Limit() method.
 *
 * Revision 1.23  2000/11/28 15:26:41  scowan
 * Added more methods.
 *
 * Revision 1.22  2000/11/07 15:58:47  scowan
 * Added casting that I believe Dave finds so unnecessary.
 *
 * Revision 1.21  2000/11/06 15:28:16  asavant
 * equality/inequality operators should return bool
 *
 * Revision 1.20  2000/11/03 21:15:13  mju
 * Add equality/inequality operators.
 *
 * Revision 1.19  2000/09/20 22:28:52  dwilliss
 * Added a few methods
 *
 * Revision 1.18  2000/08/02 14:22:02  dwilliss
 * LRECT2D didn't have a SetInvalid() method.
 *
 * Revision 1.17  2000/07/11 19:37:00  sparsons
 * Genitor documentation.
 *
 * Revision 1.16  2000/03/07 20:43:43  scowan
 * *** empty log message ***
 *
 * Revision 1.15  2000/01/26 15:51:44  mju
 * Don't use STL as MSVC won't inline it.
 *
 * Revision 1.14  2000/01/07 20:54:49  mju
 * Fix DRECT2D::GetTopRight.
 *
 * Revision 1.13  1999/12/23 00:58:23  scowan
 * Yet more methods.
 *
 * Revision 1.12  1999/12/22 16:52:23  mju
 * Add SetInvalid() for DRECT2D/3D.
 *
 * Revision 1.11  1999/12/15 17:19:53  mju
 * Add options for GetCorners and make non-inline.
 *
 * Revision 1.10  1999/12/15 16:41:06  mju
 * Restore DRECT3D::GetCenter which returns DPOINT3D.
 *
 * Revision 1.9  1999/12/15 15:55:44  mju
 * All reference for all "Get" methods that return non-scalar.
 * Eliminate return-by-value for all Get methods except GetCenter.
 * Add GetCorners() for RECT2D types.
 *
 * Revision 1.8  1999/12/02 23:23:43  mju
 * Add ClipTo method.
 *
 * Revision 1.7  1999/10/05 21:57:59  dwilliss
 * Seems to me like LRECT2D should have same methods as DRECT2D, no?
 *
 * Revision 1.6  1999/09/07 13:51:40  mju
 * Add constructors and methods for LRECT2D.
 *
 * Revision 1.5  1999/05/19  13:51:54  mju
 * Add Expand method with different X/Y values.
 * Add DRECT2D construction/assignment from LRECT2D.
 *
 * Revision 1.4  1999/05/12  16:50:02  mju
 * Add DRECT3D ctor that takes DRECT2D and z min/max values.
 *
 * Revision 1.3  1999/05/07  21:21:05  mju
 * Header restruct.
 *
 * Revision 1.1  1999/05/05  17:30:09  mju
 * Initial revision
 * \endif
**/

#ifndef  INC_MI32_RECT_H
#define  INC_MI32_RECT_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_INIDEFNS_H
#include <mi32/inidefns.h>
#endif

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

#ifndef  INC_MI32_POINT_H
#include <mi32/point.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

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

//! 2D rectangle using 16-bit integer coordinates.
struct WRECT2D {
   INT16 xinit;                     //!< Minimum X coordinate (inclusive)
   INT16 yinit;                     //!< Minimum Y coordinate (inclusive)
   INT16 xlast;                     //!< Maximum X coordinate (inclusive)
   INT16 ylast;                     //!< Maximum Y coordinate (inclusive)

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

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

//! 2D rectangle using 32-bit integer coordinates.
struct LRECT2D {

   INT32 xinit;                     //!< Minimum X coordinate (inclusive)
   INT32 yinit;                     //!< Minimum Y coordinate (inclusive)
   INT32 xlast;                     //!< Maximum X coordinate (inclusive)
   INT32 ylast;                     //!< Maximum Y coordinate (inclusive)

   //! Default constructor, initializes to invalid (empty) rectangle.
   LRECT2D (                           
      ): xinit(INT32_MAX), yinit(INT32_MAX), xlast(INT32_MIN), ylast(INT32_MIN) { }

   //! Construct rectangle of specified size.
   LRECT2D (                           
      INT32 xsize,
      INT32 ysize
      ) : xinit(0), yinit(0), xlast(xsize-1), ylast(ysize-1) { }

   //! Construction from X/Y ranges.
   LRECT2D (                           
      INT32 xi,
      INT32 yi,
      INT32 xl,
      INT32 yl
      ) : xinit(xi), yinit(yi), xlast(xl), ylast(yl) { }

   //! Check if contains specified point.
   bool Contains (                     
      INT32 x,
      INT32 y
      ) const { return (x >= xinit && x <= xlast && y >= yinit && y <= ylast); }

   //! Check if contains specified point.
   bool Contains (                     
      const LPOINT2D& pt
      ) const { return (pt.x >= xinit && pt.x <= xlast && pt.y >= yinit && pt.y <= ylast); }

   //! Check if contains specified rectangle.
   bool Contains (                     
      const LRECT2D& rhs
      ) const { return (rhs.xinit >= xinit && rhs.xlast <= xlast && rhs.yinit >= yinit && rhs.ylast <= ylast); }

   //! Expand the rectangle by 'value' amount.
   void Expand (                       
      const INT32 value
      ) { xinit -= value; yinit -= value; xlast += value; ylast += value; }
   
   //! Expand the rectangle by 'value' amount.
   void Expand (                       
      const INT32 xval,
      const INT32 yval
      ) { xinit -= xval; yinit -= yval; xlast += xval; ylast += yval; }

   //! Extend rectangle to encompass both rectangles.
   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;
      }

   //! Extend rectangle to include specified LPOINT2D point.
   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;
      }

   //! Extend rectangle to include specified X,Y point.
   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;
      }

   //! Compute area of rectangle (Could be negative if invalid rectangle).
   INT32 GetArea (
      ) const { return (GetWidth() * GetHeight()); }

   //! Return bottom left corner.
   void GetBottomLeft (                
      LPOINT2D& ret
      ) const { ret.x = xinit; ret.y = yinit; }

   //! Get bottom right corner.
   void GetBottomRight (               
      LPOINT2D& ret
      ) const { ret.x = xlast; ret.y = yinit; }

   //! Return center point of rectangle.
   DPOINT2D GetCenter (                
      ) const { return (DPOINT2D((xlast + xinit)/2.0, (ylast + yinit)/2.0)); }

   //! Get center point of rectangle.
   void GetCenter (                    
      DPOINT2D& ret
      ) const { ret.x = (xinit + xlast) / 2.0; ret.y = (yinit + ylast) / 2.0; }

   //! Get corners as array.
   void GetCorners (                   
      LPOINT2D *corners,               //!< Array of points to fill in
      bool ClosePoly = false,          //!< Return "closed" polygon, corners[4] = corners[0]
      bool OrientCCW = false           //!< Orient points in counterclockwise order for right-hand cartesian
      ) const { LRect2DGetCorners(*this, corners, ClosePoly, OrientCCW); }

   //! Compute number of non zero dimensions (0, 1, or 2).
   int GetDimension (                  
      ) const {
      int count(0);
      if (xinit < xlast) count ++;
      if (yinit < ylast) count ++;
      return (count);
      }

   //! Return height (Y size) of rectangle.
   UINT32 GetHeight (                  
      ) const { return (ylast - yinit + 1); }

   //! Get size of rectangle.
   void GetSize (                      
      LPOINT2D& ret
      ) const { ret.x = xlast - xinit; ret.y = ylast - yinit; }

   //! Return top left point of rectangle.
   void GetTopLeft (                   
      LPOINT2D& ret
      ) const { ret.x = xinit; ret.y = ylast; }

   //! Return top right point of rectangle.
   void GetTopRight (                  
      LPOINT2D& ret
      ) const { ret.x = xlast; ret.y = ylast; }

   //! Return width (X size) of rectangle.
   UINT32 GetWidth (                   
      ) const { return (xlast - xinit + 1); }

   //! Read rectangle from INI file.
   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) { return (_iniRead(IniHandle,IniGroup,IniName,INITYPE_INT32,this,4) == 4); }

   //! Read rectangle from INI file.
   void IniWrite (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) const { _iniWrite(IniHandle,IniGroup,IniName,INITYPE_INT32,this,4); }

   //! Intersect two DRECT2D's, may result in an invalid rectangle.
   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;
      }

   //! Check if rectangle is valid.
   bool IsValid (                      
      ) const { return (xinit <= xlast && yinit <= ylast); }

   //! Limit point (LPOINT2D) to extents specified by rectangle.
   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;
      }

   //! Limit point (DPOINT2D) to extents specified by rectangle.
   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;
      }

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

   //! Sets the initial values to the maximum possible and the final values to the minimum possible, thus making the rectangle "invalid".
   //! Setting a rectangle to invalid means that no point will be in it.  It also makes it easy 
   //! to compute the min/max of a bunch of points.  You just iterate through all the points 
   //! and Extend() the rectangle.  Normally, you'd have to handle the first point specially.
   void SetInvalid (
      ) { xinit = yinit = INT32_MAX; xlast = ylast = INT32_MIN; }

   //! Perform byte-order swapping.
   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); }

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

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


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

//! 2D rectangle using 'double' precision coordinates.
struct DRECT2D {
   
   double xinit;                    //!< Minimum X coordinate (inclusive)
   double yinit;                    //!< Minimum Y coordinate (inclusive)
   double xlast;                    //!< Maximum X coordinate (inclusive)
   double ylast;                    //!< Maximum Y coordinate (inclusive)

   //! Default constructor, initialize to "invalid" area.
   DRECT2D (                           
      ) : xinit(DBL_MAX), yinit(DBL_MAX), xlast(-DBL_MAX), ylast(-DBL_MAX) {
      }

   //! Construct from FPOINT2D (or FPOINT3D).
   DRECT2D (                           
      const FPOINT2D& pt
      ) : xinit(pt.x), yinit(pt.y), xlast(pt.x), ylast(pt.y) { }

   //! Construct from DPOINT2D (or DPOINT3D).
   DRECT2D (                           
      const DPOINT2D& pt
      ) : xinit(pt.x), yinit(pt.y), xlast(pt.x), ylast(pt.y) { }

   //! Construct from two DPOINT2D's (or DPOINT3D's).
   //! A regular ctor from DPOINT2D and then a call to ::Extend(DPOINT2D&) would use
   //! 6 assignments and 4 comparisons, this uses 2 compares and 4 assignments
   DRECT2D (                           
      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;
         }
      }

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

   //! Implicit conversion from LRECT2D.
   DRECT2D (                           
      const LRECT2D& rect
      ) : xinit(rect.xinit), yinit(rect.yinit), xlast(rect.xlast), ylast(rect.ylast) { }

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

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

   //! Clip this rectangle to specified rectangle.
   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;
      }

   //! Given the center point of the DRECT2D and the 'TestPt' which is outside the box,
   //! compute the point on the edge of the box which falls between the center point and
   //! the 'TestPt'.
   //! @return 'true' if the point is found, false if the 'TestPt' is inside the box or the box is invalid
   bool ComputeEdgePoint (
      const DPOINT2D& OutsidePt,       //!< Point outside of 'this' 
      DPOINT2D& EdgePt                 //!< Point on the rectangle edge RETURNED if 'true' returned, center of the box if 'false' is returned
      ) const { return (DRect2DComputeEdgePoint(*this, OutsidePt, EdgePt)); }

   //! Check if contains specified point.
   bool Contains (                     
      double x,
      double y
      ) const { return (x >= xinit && x <= xlast && y >= yinit && y <= ylast); }

   //! Check if contains specified point.
   bool Contains (                     
      const DPOINT2D& pt
      ) const { return (pt.x >= xinit && pt.x <= xlast && pt.y >= yinit && pt.y <= ylast); }

   //! Check if contains specified point.
   bool Contains (                     
      const DRECT2D& rhs
      ) const { return (rhs.xinit >= xinit && rhs.xlast <= xlast && rhs.yinit >= yinit && rhs.ylast <= ylast); }

   //! Expand the rectangle by 'value' amount.
   void Expand (                       
      const double value
      ) { xinit -= value; yinit -= value; xlast += value; ylast += value; }

   //! Expand the rectangle by 'value' amount.
   void Expand (                       
      const double xval,
      const double yval
      ) { xinit -= xval; yinit -= yval; xlast += xval; ylast += yval; }

   //! Extend rectangle to include specified X,Y point.
   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;
      }

   //! Extend rectangle to encompass both rectangles.
   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;
      }

   //! Extend rectangle to include specified DPOINT2D point.
   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;
      }

   //! Compute area of rectangle.
   double GetArea (                    
      ) const { return ((xlast - xinit) * (ylast - yinit)); }

   //! Return bottom left point of rectangle.
   void GetBottomLeft (                
      DPOINT2D& ret
      ) const { ret.x = xinit; ret.y = yinit; }

   //! Return bottom right point of rectangle.
   void GetBottomRight (               
      DPOINT2D& ret
      ) const { ret.x = xlast; ret.y = yinit; }

   //! Return center point of rectangle.
   DPOINT2D GetCenter (                
      ) const { return (DPOINT2D((xlast + xinit)/2.0, (ylast + yinit)/2.0)); }

   //! Return center point of rectangle.
   void GetCenter (                    
      DPOINT2D& ret
      ) const { ret.x = (xinit + xlast) / 2.0; ret.y = (yinit + ylast) / 2.0; }

   //! Get corners as array.
   void GetCorners (                   
      DPOINT2D *corners,               //!< Array of points to fill in
      bool ClosePoly = false,          //!< Return "closed" polygon, corners[4] = corners[0]
      bool OrientCCW = false           //!< Orient points in counterclockwise order for right-hand cartesian
      ) const { DRect2DGetCorners(*this, corners, ClosePoly, OrientCCW); }

   //! Get corners as array.
   void GetCorners (                   
      DPOINT3D *corners,               //!< Array of points to fill in
      bool ClosePoly = false,          //!< Return "closed" polygon, corners[4] = corners[0]
      bool OrientCCW = false           //!< Orient points in counterclockwise order for right-hand cartesian
      ) const { DRect2DGetCorners(*this, corners, ClosePoly, OrientCCW); }

   //! Compute number of non zero dimensions (0, 1, or 2).
   int GetDimension (                  
      ) const {
      int count(0);
      if (xinit < xlast) count ++;
      if (yinit < ylast) count ++;
      return (count);
      }

   //! Compute the distance between two disjoint rectangles
   //! @return Distance between two disjoint rectangles, 0.0 if they overlap.
   double GetDistance (
      const DRECT2D& rect
      ) const { return (DRect2DGetDistance(*this, rect)); }

   //! Return height of rectangle.
   double GetHeight (                  
      ) const { return (ylast - yinit); }

   //! Compute the maximum distance between two rectangles
   //! Uses Extend() and then computes the diagonal distance
   //! @return Max distance between two rectangles
   double GetMaxDistance (
      const DRECT2D& rect
      ) const { return (DRect2DGetMaxDistance(*this, rect)); }

   //! Compute the maximum distance between two rectangles
   //! Uses Extend() and then computes the diagonal distance
   //! @return Max distance between two rectangles
   double GetMaxDistanceSquared (
      const DRECT2D& rect
      ) const { return (DRect2DGetMaxDistanceSquared(*this, rect)); }

   //! Get the rectangle as an LRECT2D (with rounding)
   void GetRect (
      LRECT2D& rect
      ) const {
      rect.xinit = static_cast<INT32>(FAST_ROUND(xinit));
      rect.yinit = static_cast<INT32>(FAST_ROUND(yinit));
      rect.xlast = static_cast<INT32>(FAST_ROUND(xlast));
      rect.ylast = static_cast<INT32>(FAST_ROUND(ylast));
      return;
      }

   //! Get the rectangle as an LRECT2D (with truncating towards 0)
   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));
      return;
      }

   //! Get size of rectangle.
   void GetSize (                      
      DPOINT2D& ret
      ) const { ret.x = xlast - xinit; ret.y = ylast - yinit; }

   //! Return top left point of rectangle.
   void GetTopLeft (                   
      DPOINT2D& ret
      ) const { ret.x = xinit; ret.y = ylast; }

   //! Return top right point of rectangle.
   void GetTopRight (                  
      DPOINT2D& ret
      ) const { ret.x = xlast; ret.y = ylast; }

   //! Return width of rectangle.
   double GetWidth (                   
      ) const { return (xlast - xinit); }

   //! Read rectangle from INI file.
   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) { return (_iniRead(IniHandle,IniGroup,IniName,INITYPE_DRECT2D,this,1) == 1); }

   //! Read rectangle from INI file with default.
   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); } }

   //! Read rectangle from INI file.
   void IniWrite (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) const { _iniWrite(IniHandle,IniGroup,IniName,INITYPE_DRECT2D,this,1); }

   //! Intersect two DRECT2D's, may result in an invalid rectangle.
   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;
         }
      return;
      }
      
   //! Determine if the two rectangles are equivalent 
   //! This method uses "Fuzzy" edge comparisons
   //! Specify a different threshold to allow greater distances
   //! @return 'True' if they are, 'False' if not
   bool IsEquivalentTo (
      const DRECT2D& rhs,
      double threshold = 0.0        //!< Default threshold is max absolute value of rectangle coordinate * 1.0E-13
      ) const { return (DRect2DIsEquivalentTo(*this, rhs, threshold)); }

   //! Check if rectangle is valid.
   bool IsValid (                      
      ) const { return (xinit <= xlast && yinit <= ylast); }

   //! Limit point to extents specified by rectangle.
   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;
      return;
      }

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

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

   //! Sets the initial values to the maximum possible and the final values to the minimum possible, thus making the rectangle "invalid".
   //! Setting a rectangle to invalid means that no point will be in it.  It also makes it easy 
   //! to compute the min/max of a bunch of points.  You just iterate through all the points 
   //! and Extend() the rectangle.  Normally, you'd have to handle the first point specially.
   void SetInvalid (
      ) { xinit = yinit = DBL_MAX; xlast = ylast = -DBL_MAX; }

   //! Perform byte-order swapping.
   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); }

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

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

//! Read 'DRECT2D' value from INI file.
inline int IniRead (INIHANDLE hdl, const char *group, const char *field, DRECT2D& value) { return (_iniRead(hdl,group,field,INITYPE_DRECT2D,&value,1)); }

//! Read 'DRECT2D' value from INI file with default.
inline int IniRead (INIHANDLE hdl, const char *group, const char *field, DRECT2D& value, const DRECT2D& dft) { value = dft; return (IniRead(hdl,group,field,value)); }

//! Write 'DRECT2D' value to INI file.
inline int IniWrite (INIHANDLE hdl, const char *group, const char *field, const DRECT2D& value) { return (_iniWrite(hdl,group,field,INITYPE_DRECT2D,&value,1)); }


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

//! 3D rectangle using 'double' precision coordinates.
struct DRECT3D : public DRECT2D {
   
   double zinit;
   double zlast;

   //! Initialize to nonexistent area.
   DRECT3D (                           
      ) : DRECT2D(), zinit(DBL_MAX), zlast(-DBL_MAX) { }

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

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

   //! Construct from two DPOINT3D's
   //! A regular ctor from DPOINT3D and then a call to ::Extend(DPOINT3D&) would use
   //! 9 assignments and 6 comparisons, this uses 3 compares and 6 assignments
   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;
         }
      }

   //! Construct from DRECT2D.
   DRECT3D (                           
      const DRECT2D& rect
      ) : DRECT2D(rect), zinit(0.0), zlast(0.0) { }

   //! Construct from DRECT2D and Z min/max.
   DRECT3D (                           
      const DRECT2D& rect,
      double zmin,
      double zmax
      ) : DRECT2D(rect), zinit(zmin), zlast(zmax) { }

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

   //! Check if point is inside.
   bool Contains (                     
      const DPOINT3D& pt
      ) const { return (DRECT2D::Contains(pt) && pt.z >= zinit && pt.z <= zlast); }
   
   //! Check if rectangle is inside.
   bool Contains (                     
      const DRECT3D& rhs
      ) const { return (DRECT2D::Contains(rhs) && rhs.zinit >= zinit && rhs.zlast <= zlast); }

   //! Expand the rectangle by 'value' amount.
   void Expand (                       
      const double value
      ) {
      DRECT2D::Expand(value);
      zinit -= value; zlast += value;
      return;
      }

   //! Expand the rectangle by 'value' amount.
   void Expand (                       
      const double xval,
      const double yval
      ) { DRECT2D::Expand(xval, yval); }

   //! Extend rectangle to encompass both rectangles.
   void Extend (                       
      const double xval,
      const double yval
      ) { DRECT2D::Extend(xval, yval); }

   //! Extend rectangle to encompass both rectangles.
   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;
      }

   //! Union rectangles together, resulting rect is extents of both
   void Extend (                       
      const DRECT3D& rect
      ) {
      DRECT2D::Extend(rect);
      if (rect.zinit < zinit) zinit = rect.zinit;
      if (rect.zlast > zlast) zlast = rect.zlast;
      return;
      }

   //! Extend to contain specified point.
   void Extend (                       
      const DPOINT2D& pt
      ) { DRECT2D::Extend(pt); }

   //! Extend to contain specified point.
   void Extend (                       
      const DPOINT3D& pt
      ) {
      DRECT2D::Extend(pt);
      if (pt.z < zinit) zinit = pt.z;
      if (pt.z > zlast) zlast = pt.z;
      return;
      }

   //! Return center of the box.
   DPOINT3D GetCenter (
      ) const { return (DPOINT3D((xinit+xlast)/2.0,(yinit+ylast)/2.0,(zinit+zlast)/2.0)); }

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

   //! Return depth of the box (z distance).
   double GetDepth (                   
      ) const { return (zlast - zinit); }

   //! Compute number of non zero dimensions (0, 1, 2, or 3).
   int GetDimension (                  
      ) const {
      int count(DRECT2D::GetDimension());
      if (zinit < zlast) count ++;
      return (count);
      }

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

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

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

   //! Compute volume of box.
   double GetVolume (                  
      ) const { return (DRECT2D::GetArea() * (zlast - zinit)); }

   //! Read rectangle from INI file.
   bool IniRead (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) { return (_iniRead(IniHandle,IniGroup,IniName,INITYPE_Double,this,6) == 6); }

   //! Read rectangle from INI file.
   void IniWrite (
      INIHANDLE IniHandle,
      const char *IniGroup,
      const char *IniName
      ) const { _iniWrite(IniHandle,IniGroup,IniName,INITYPE_Double,this,6); }

   //! Intersect two DRECT3D's, may result in an invalid rectangle.
   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;
      }
   
   //! Check if rectangle is valid.
   bool IsValid (                      
      ) const { return (DRECT2D::IsValid() && zinit <= zlast); }

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

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

   //! Sets the initial values to the maximum possible and the final values to the minimum possible, thus making the rectangle "invalid".
   //!
   //! Setting a rectangle to invalid means that no point will be in it.  It also makes it easy 
   //! to compute the min/max of a bunch of points.  You just iterate through all the points 
   //! and Extend() the rectangle.  Normally, you'd have to handle the first point specially.
   void SetInvalid (
      ) { DRECT2D::SetInvalid(); zinit = DBL_MAX; zlast = -DBL_MAX; }

   //! Perform byte-order swapping.
   void SwapBytes (
      ) { ::SwapBytes(xinit); ::SwapBytes(xlast); ::SwapBytes(yinit); ::SwapBytes(ylast); ::SwapBytes(zinit); ::SwapBytes(zlast); }

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

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   //!< INC_MI32_RECT_H

---