GeExtents3d.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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-2022 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 _ODGEEXTENTS3D_INCLUDED_
#define _ODGEEXTENTS3D_INCLUDED_ 
#include "Ge/GePoint3d.h"
#include "Ge/GeVector3d.h"
#include "Ge/GeMatrix3d.h"
 
#include "TD_PackPush.h"
 
class OdGeExtents2d;
 
#define INVALIDEXTENTS 1.0e20
 
class GE_TOOLKIT_EXPORT OdGeExtents3d
{
public:
 
  OdGeExtents3d();
 
  OdGeExtents3d(
    const OdGePoint3d& min, 
    const OdGePoint3d& max);
 
  GE_STATIC_EXPORT static const OdGeExtents3d kInvalid;
 
  const OdGePoint3d& minPoint() const;
 
  const OdGePoint3d& maxPoint() const;
 
  const OdGePoint3d& operator[] (int iIndex) const {
    return iIndex == 0 ? m_min : m_max;
  }
  
  OdGePoint3d& operator[] (int iIndex) {
    return iIndex == 0 ? m_min : m_max;
  }
 
  void set(
    const OdGePoint3d& min, 
    const OdGePoint3d& max);
 
  void comparingSet(
    const OdGePoint3d& pt1, 
    const OdGePoint3d& pt2);
 
  OdGeExtents3d& addPoint(
    const OdGePoint3d& point);
 
  OdGeExtents3d& addPoints(
    const OdGePoint3dArray& points);
 
  OdGeExtents3d& addExt(
    const OdGeExtents3d& extents);
 
  inline bool isValidExtents() const
  {
    return ( (m_max.x >= m_min.x) && (m_max.y >= m_min.y) && (m_max.z >= m_min.z));
  }
 
    void expandBy(
    const OdGeVector3d& vect);
 
  void transformBy(
    const OdGeMatrix3d& xfm);
    
  bool contains(
    const OdGePoint3d& point, const OdGeTol& tol = OdGeContext::gTol) const;
 
  bool contains(
    const OdGeExtents3d& extents, const OdGeTol& tol = OdGeContext::gTol) const;
 
  bool isDisjoint(
    const OdGeExtents3d& extents, const OdGeTol& tol = OdGeContext::gTol) const;
 
  bool isDisjointEuclidean(
    const OdGeExtents3d& extents, const OdGeTol& tol = OdGeContext::gTol) const;
 
  double distanceTo(const OdGePoint3d& iPoint) const;
 
  double distanceTo(const OdGeExtents3d& iExtents) const;
 
  enum IntersectionStatus
  {
    kIntersectUnknown,
    kIntersectNot,
    kIntersectOpIn,
    kIntersectOpOut,
    kIntersectOk
  };
 
  IntersectionStatus intersectWith(const OdGeExtents3d& extents, OdGeExtents3d* pResult = 0) const;
  
  bool isWithinRange(const OdGePoint3d &pt, double radius);
 
  OdGePoint3d center() const
  {
    return m_min + (m_max - m_min) * 0.5;
  }
  
  OdGeVector3d diagonal() const
  {
    return m_max - m_min;
  }
 
  enum Convert2dPlane
  {
    kConvert2dPlaneXY = 0x04,
    kConvert2dPlaneXZ = 0x08,
    kConvert2dPlaneYX = 0x01,
    kConvert2dPlaneYZ = 0x09,
    kConvert2dPlaneZX = 0x02,
    kConvert2dPlaneZY = 0x06
  };
  
  void convert2d(OdGeExtents2d &extents, Convert2dPlane plane = kConvert2dPlaneXY) const;
  
  void setFrom2d(const OdGeExtents2d &extents, Convert2dPlane plane = kConvert2dPlaneXY);
 
  bool isEqualTo(const OdGeExtents3d& extents, const OdGeTol& tol = OdGeContext::gTol) const;
 
  bool operator ==(const OdGeExtents3d& extents) const
  {
    return isEqualTo(extents);
  }
  
  bool operator !=(const OdGeExtents3d& extents) const
  {
    return !isEqualTo(extents);
  }
//DOM-IGNORE-BEGIN
protected:
  OdGePoint3d m_min;
  OdGePoint3d m_max;
//DOM-IGNORE-END
};
 
// Inline implementations
 
inline OdGeExtents3d::OdGeExtents3d()
  : m_min(INVALIDEXTENTS,  INVALIDEXTENTS,  INVALIDEXTENTS)
  , m_max(-INVALIDEXTENTS, -INVALIDEXTENTS, -INVALIDEXTENTS)
{
}
 
inline OdGeExtents3d::OdGeExtents3d(const OdGePoint3d& min, const OdGePoint3d& max)
  : m_min(min)
  , m_max(max)
{
}
 
inline const OdGePoint3d& OdGeExtents3d::minPoint() const
{
  return m_min;
}
 
inline const OdGePoint3d& OdGeExtents3d::maxPoint() const
{
  return m_max;
}
 
inline void OdGeExtents3d::set(const OdGePoint3d& min, const OdGePoint3d& max)
{
  //ODA_ASSERT_ONCE(min.x <= max.x);
  //ODA_ASSERT_ONCE(min.y <= max.y);
  //ODA_ASSERT_ONCE(min.z <= max.z);
  m_min = min;
  m_max = max;
}
 
inline void OdGeExtents3d::comparingSet(const OdGePoint3d& pt1, const OdGePoint3d& 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);
  m_min.z = odmin(pt1.z, pt2.z);
  m_max.z = odmax(pt1.z, pt2.z);
}
 
inline OdGeExtents3d& OdGeExtents3d::addPoint(const OdGePoint3d& point)
{
  if ((m_max.x < m_min.x) || (m_max.y < m_min.y) || (m_max.z < m_min.z))
  {
    //TODO: it's better to remove this case for better performance!
    m_max = m_min = point;
  }
  else
  {
    m_min.x = odmin(m_min.x, point.x);
    m_max.x = odmax(m_max.x, point.x);
    m_min.y = odmin(m_min.y, point.y);
    m_max.y = odmax(m_max.y, point.y);
    m_min.z = odmin(m_min.z, point.z);
    m_max.z = odmax(m_max.z, point.z);
  }
  return *this;
}
 
inline OdGeExtents3d& OdGeExtents3d::addExt(const OdGeExtents3d& extents)
{
  ODA_ASSERT(extents.isValidExtents());
 
#if 0
  addPoint(extents.minPoint());
  addPoint(extents.maxPoint());
#else
  if ((m_max.x < m_min.x) || (m_max.y < m_min.y) || (m_max.z < m_min.z))
  {
    //TODO: it's better to remove this case for better performance!
    set(extents.minPoint(), extents.maxPoint());
  }
  else
  {
    m_min.x = odmin(m_min.x, extents.m_min.x);
    m_max.x = odmax(m_max.x, extents.m_max.x);
    m_min.y = odmin(m_min.y, extents.m_min.y);
    m_max.y = odmax(m_max.y, extents.m_max.y);
    m_min.z = odmin(m_min.z, extents.m_min.z);
    m_max.z = odmax(m_max.z, extents.m_max.z);
  }
#endif
  return *this;
}
 
inline void OdGeExtents3d::expandBy(const OdGeVector3d& vect)
{
  ODA_ASSERT(isValidExtents());
 
  OdGePoint3d p1 = m_min, p2 = m_max;
  addPoint(p1 + vect);
  addPoint(p2 + vect);
}    
 
inline bool OdGeExtents3d::contains(const OdGePoint3d& 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.z + tol.equalPoint()) >= m_min.z
    && (point.x - tol.equalPoint()) <= m_max.x
    && (point.y - tol.equalPoint()) <= m_max.y
    && (point.z - tol.equalPoint()) <= m_max.z );
}
 
inline bool OdGeExtents3d::contains(const OdGeExtents3d& 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 
    && (extents.m_min.z + tol.equalPoint()) >= m_min.z 
    && m_max.x >= (extents.m_max.x - tol.equalPoint()) 
    && m_max.y >= (extents.m_max.y - tol.equalPoint()) 
    && m_max.z >= (extents.m_max.z - tol.equalPoint()));
}    
 
inline bool OdGeExtents3d::isDisjoint(const OdGeExtents3d& 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 
    || (extents.m_min.z - tol.equalPoint()) > m_max.z
    || m_min.x > (extents.m_max.x + tol.equalPoint())
    || m_min.y > (extents.m_max.y + tol.equalPoint())
    || m_min.z > (extents.m_max.z + tol.equalPoint()));
}    
 
#undef INVALIDEXTENTS
 
#include "TD_PackPop.h"
 
#endif //_ODGEEXTENTS3D_INCLUDED_