GeExtents2d.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _ODGEEXTENTS2D_INCLUDED_
#define _ODGEEXTENTS2D_INCLUDED_ 
 
#include "Ge/GePoint2d.h"
#include "Ge/GePoint2dArray.h"
#include "Ge/GeVector2d.h"
#include "Ge/GeMatrix2d.h"
 
#include "TD_PackPush.h"
 
#define INVALIDEXTENTS 1.0e20

class GE_TOOLKIT_EXPORT OdGeExtents2d
{
public:

  OdGeExtents2d()
    : m_min(INVALIDEXTENTS,  INVALIDEXTENTS)
    , m_max(-INVALIDEXTENTS, -INVALIDEXTENTS)
  {}

  OdGeExtents2d (
    const OdGePoint2d& min, 
    const OdGePoint2d& max) 
  { set(min, max); }

  GE_STATIC_EXPORT static const OdGeExtents2d kInvalid;

  const OdGePoint2d& minPoint() const 
  { return m_min; }

  const OdGePoint2d& maxPoint() const 
  { return m_max; }

  OdGeVector2d diagonal() const 
  { return m_max - m_min; }

  void set(const OdGePoint2d& min, const OdGePoint2d& max) 
  { 
    //ODA_ASSERT_ONCE(min.x <= max.x);
    //ODA_ASSERT_ONCE(min.y <= max.y);
    m_min = min; m_max = max; 
  }

  void comparingSet(
    const OdGePoint2d& pt1,
    const OdGePoint2d& pt2);

  OdGeExtents2d& addPoint(
    const OdGePoint2d& point)
  {
    if (!isValidExtents())
    {
      m_max = m_min = point;
    }
    else
    {
      m_max.x = odmax (point.x, m_max.x);
      m_max.y = odmax (point.y, m_max.y);
      m_min.x = odmin (point.x, m_min.x);
      m_min.y = odmin (point.y, m_min.y);
    }
    return *this;
  }

  OdGeExtents2d& addPoints(const OdGePoint2dArray& points);

  OdGeExtents2d& addExt(
    const OdGeExtents2d& extents)
  {
    if (extents.isValidExtents())
    {
      addPoint (extents.minPoint());
      addPoint (extents.maxPoint());
    }
    return *this;
  }

  bool isValidExtents() const
  {
    return ((m_max.x >= m_min.x) && (m_max.y >= m_min.y));
  }

  void expandBy(
    const OdGeVector2d& vect);

  void transformBy(
    const OdGeMatrix2d& xfm);
    
  void translate(
    const OdGeVector2d &iShift)
  {
    m_min += iShift;
    m_max += iShift;
  }

  bool contains(
    const OdGePoint2d& point, const OdGeTol& tol = OdGeContext::gTol) const;

  bool contains(
    const OdGeExtents2d& extents, const OdGeTol& tol = OdGeContext::gTol) const;

  bool isDisjoint(
    const OdGeExtents2d& extents, const OdGeTol& tol = OdGeContext::gTol) const;  

  enum IntersectionStatus
  {
    kIntersectUnknown,
    kIntersectNot,
    kIntersectOpIn,
    kIntersectOpOut,
    kIntersectOk
  };

  IntersectionStatus intersectWith(
    const OdGeExtents2d& extents, 
    OdGeExtents2d* pResult = 0) const;

  OdGePoint2d center() const
  {
    return OdGePoint2d(0.5 * (m_min.x + m_max.x), 0.5 * (m_min.y + m_max.y));
  }

  bool isEqualTo(const OdGeExtents2d& extents, const OdGeTol& tol = OdGeContext::gTol) const;

  bool operator ==(const OdGeExtents2d& extents) const
  {
    return isEqualTo(extents);
  }
  
  bool operator !=(const OdGeExtents2d& extents) const
  {
    return !isEqualTo(extents);
  }
//DOM-IGNORE-BEGIN
protected:
  OdGePoint2d m_min;
  OdGePoint2d m_max;
//DOM-IGNORE-END
};
 
// Inlines section
 
inline void OdGeExtents2d::comparingSet(const OdGePoint2d& pt1, const OdGePoint2d& pt2)
{
  m_min.x = odmin(pt1.x, pt2.x);
  m_max.x = odmax(pt1.x, pt2.x);
  m_min.y = odmin(pt1.y, pt2.y);
  m_max.y = odmax(pt1.y, pt2.y);
}
 
inline bool OdGeExtents2d::contains(const OdGePoint2d& point, const OdGeTol& tol) const
{
  //ODA_ASSERT(isValidExtents());   //note: empty/invalid box does NOT contain any point
 
  return ( (point.x + tol.equalPoint()) >= m_min.x
    && (point.y + tol.equalPoint()) >= m_min.y
    && (point.x - tol.equalPoint()) <= m_max.x
    && (point.y - tol.equalPoint()) <= m_max.y );
}
 
inline bool OdGeExtents2d::contains(const OdGeExtents2d& extents, const OdGeTol& tol) const
{
  ODA_ASSERT(isValidExtents());
 
  return ((extents.m_min.x + tol.equalPoint()) >= m_min.x 
    && (extents.m_min.y + tol.equalPoint()) >= m_min.y 
    && m_max.x >= (extents.m_max.x - tol.equalPoint()) 
    && m_max.y >= (extents.m_max.y - tol.equalPoint()));
}
 
inline bool OdGeExtents2d::isDisjoint(const OdGeExtents2d& extents, const OdGeTol& tol) const
{
  //ODA_ASSERT(isValidExtents());   //note: empty/invalid box is disjoint with everything
 
  return ((extents.m_min.x - tol.equalPoint()) > m_max.x 
    || (extents.m_min.y - tol.equalPoint()) > m_max.y 
    || m_min.x > (extents.m_max.x + tol.equalPoint())
    || m_min.y > (extents.m_max.y + tol.equalPoint()));
} 

inline void pointsExtents(OdGePoint2d& minPt, OdGePoint2d& maxPt
  , const OdGePoint2d& pt1, const OdGePoint2d& pt2)
{
  if (pt1.x <= pt2.x)
  {
    minPt.x = pt1.x;
    maxPt.x = pt2.x;
  }
  else
  {
    minPt.x = pt2.x;
    maxPt.x = pt1.x;
  }
 
  if (pt1.y <= pt2.y)
  {
    minPt.y = pt1.y;
    maxPt.y = pt2.y;
  }
  else
  {
    minPt.y = pt2.y;
    maxPt.y = pt1.y;
  }
}

inline bool extendExtents(double& minValue, double& maxValue, const double& value)
{
  ODA_ASSERT(minValue <= maxValue);
 
  if (value < minValue)
  {
    minValue = value;
 
    return true;
  }
 
  if (value > maxValue)
  {
    maxValue = value;
 
    return true;
  }
 
  return false;
}

inline bool extendExtents(OdGePoint2d& minPt, OdGePoint2d& maxPt, const OdGePoint2d& pt)
{
  bool extended = extendExtents(minPt.x, maxPt.x, pt.x);
 
  extended |= extendExtents(minPt.y, maxPt.y, pt.y);
 
  return extended;
}

inline bool isBoxContainsPoint(const OdGePoint2d& minPt, const OdGePoint2d& maxPt
  , const OdGePoint2d& pt, const OdGeTol& tol = OdGeContext::gTol)
{
  ODA_ASSERT(minPt.x <= maxPt.x);
  ODA_ASSERT(minPt.y <= maxPt.y);
 
  return (OdGreaterOrEqual(pt.x, minPt.x, tol.equalPoint())
    && OdGreaterOrEqual(pt.y, minPt.y, tol.equalPoint())
    && OdLessOrEqual(pt.x, maxPt.x, tol.equalPoint())
    && OdLessOrEqual(pt.y, maxPt.y, tol.equalPoint()));
}
 
#undef INVALIDEXTENTS
 
#include "TD_PackPop.h"
 
#endif //_ODGEEXTENTS2D_INCLUDED_