MBR最小外包矩形对象的封装

最小外包矩形对象的封装

最小外包矩形MBR就是包围图元，且平行于X，Y轴的最小外接矩形。

  template<class T>
  struct CGeoRect
  {
      // Four corner points
      T m_minX;
      T m_minY;
      T m_maxX;
      T m_maxY;

      //
      // Constructors and deconstructor
      //
      /**
      * Default constructor with no any sense.
*
* Note:
* 1) If passed by self-defined data type, it must have copy constructor being responsible for
* converting doulbe to it.
* 2) Since we adopt UEZERO as invalid point which makes sense when not initialized before being used,
* we had better notice the assertion happen before correctly using one geometry.
      */
      CGeoRect() : m_minX(-1.), m_minY(-1.), m_maxX(-1.), m_maxY(-1.)
      {
      }

      /**
      * Default constructor with specified corner values.
      */
      CGeoRect(const T &minX, const T &minY, const T &maxX, const T& maxY) : m_minX(minX),
    m_minY(minY), m_maxX(maxX), m_maxY(maxY)
      {
      }

      /**
      * Copy constructor.
*
* Note: If passed by self-defined data type, it must overload assignment operator
      */
      CGeoRect(const CGeoRect &other)
      {
          m_minX = other.m_minX;
          m_maxY = other.m_maxY;
          m_maxX = other.m_maxX;
          m_minY = other.m_minY;
      }

      /**
* Deconstructor.
*
      * Note:Since we want to take it as inner built-in type, it no need to inherit children and
      * virtual constructor may cause different behavior when against different compilers
      */
      ~CGeoRect()
      {
      }

      //
      // Simple interfaces
      //
/**
      * Check whether is an valid rectangle.
**/
bool IsValid() const
{
    return !((m_minX == m_maxX && m_minX == static_cast<T>(UE_INVALIDCOORD)) ||
        (m_minY == m_maxY && m_minY == static_cast<T>(UE_INVALIDCOORD)));
}

      /**
      * Disable this rectangle.
      */
      void Empty()
      {
          m_minX = m_maxX = m_minY = m_maxY = static_cast<T>(UE_ZERO);
      }

      /**
      * Check whether is an rectangle have an validate area.
      */
      bool IsEmpty() const
      {
    //assert(IsValid());

    return (m_minX == m_maxX ||
        m_maxY == m_minY ||
        (m_maxX - m_minX) < static_cast<T>(RECTLIMIT) ||
        (m_maxY - m_minY) < static_cast<T>(RECTLIMIT));
      }

      /**
      * Check whether intersect another rectangle.
      */
      inline bool IsIntersect(const CGeoRect<T> &other) const
      {
    //assert(IsValid());
          if(m_maxY < other.m_minY ||
        m_minY > other.m_maxY ||
        m_maxX < other.m_minX ||
        m_minX > other.m_maxX)
          {
              return false;
          }

          return true;
      }

      /**
      * Check whether contains another smaller rectangle including overstacked borders.
      */
      bool IsContain(const CGeoRect<T> &other) const
      {
    if(IsValid())
    {
        if(other.m_minX >= m_minX &&
            other.m_maxX <= m_maxX &&
            other.m_minY >= m_minY &&
            other.m_maxY <= m_maxY)
        {
            return true;
        }
    }

          return false;
      }

      /**
      * Check whether contain one point.
      */
      bool IsContain(const CGeoPoint<T> &point)
      {
    if(IsValid())
    {
        // Exception even if given this rectangle as one line segment
        double minX = m_minX;
        double maxX = m_maxX;
        if(m_minX == m_maxX)
        {
            minX -= 5;
            maxX += 5;
        }

        // Exception even if given this rectangle as one line segment
        double minY = m_minY;
        double maxY = m_maxY;
        if(m_minY == m_maxY)
        {
            minY -= 5;
            maxY += 5;
        }

        if(point.m_x < minX ||
            point.m_x > maxX ||
            point.m_y < minY ||
            point.m_y > maxY)
        {
            return false;
        }

           return true;
    }

    return false;
      }

      /**
      * Check whether contain one point.
      */
      bool IsContain(const CGeoPoint<T> &point) const
      {
    //assert(IsValid());
          if(point.m_x < m_minX ||
              point.m_x > m_maxX ||
              point.m_y < m_minY ||
              point.m_y > m_maxY)
          {
              return false;
          }

          return true;
      }

      /**
      * Union two rectangles.
      */
      void Union(const CGeoRect<T> &other)
      {
    //assert(IsValid());

          if(m_minX > other.m_minX)
          {
              m_minX = other.m_minX;
          }
          if(m_maxX < other.m_maxX)
          {
              m_maxX = other.m_maxX;
          }

          if(m_minY > other.m_minY)
          {
              m_minY = other.m_minY;
          }
          if(m_maxY < other.m_maxY)
          {
              m_maxY = other.m_maxY;
          }
      }

/**
* Enlarge this rectangle.
*/
bool Inflate(T xShift, T yShift)
{
    //assert(IsValid());

    m_minX -= xShift;
    m_maxX += xShift;
    m_minY -= yShift;
    m_maxY += yShift;

    return !IsEmpty();
}

/**
* Shrink this rectangle.
*/
bool Deflate(T xShift, T yShift)
{
    //assert(IsValid());

    m_minX += xShift;
    m_maxX -= xShift;
    m_minY += yShift;
    m_maxY -= yShift;

    return !IsEmpty();
}

      /**
      * Get rectangle width.
      */
      T Width() const
      {
    //assert(IsValid());

          return m_maxX - m_minX;
      }

      /**
      * Get rectangle height.
      */
      T Height() const
      {
    //assert(IsValid());
          return m_maxY - m_minY;
      }

      //
      // Useful overloaded operators
      //
      /**
      * Overload assignment operator.
      */
      const CGeoRect &operator = (const CGeoRect &other)
      {
    //assert(other.IsValid());
          if(this == &other)
          {
              return *this;
          }

          m_minX = other.m_minX;
          m_maxY = other.m_maxY;
          m_maxX = other.m_maxX;
          m_minY = other.m_minY;

          return *this;
      }

      /**
      * Overload bool operator.
      */
      bool operator == (const CGeoRect &other) const
      {
    //assert(IsValid());
    if(m_minX == other.m_minX &&
        m_maxY == other.m_maxY &&
        m_maxX == other.m_maxX &&
        m_minY == other.m_minY)
          {
              return true;
          }

          return false;
      }
  };