///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, 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 Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 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_ /*!DOM*/
|
|
#include "Ge/GePoint3d.h"
|
#include "Ge/GeVector3d.h"
|
#include "Ge/GeMatrix3d.h"
|
|
#include "TD_PackPush.h"
|
|
class OdGeExtents2d;
|
|
#define INVALIDEXTENTS 1.0e20 /*!DOM*/
|
|
/** \details
|
This class represents 3D bounding boxes as minimum and maximum 3d points.
|
|
Library: TD_Ge
|
|
<group OdGe_Classes>
|
*/
|
class GE_TOOLKIT_EXPORT OdGeExtents3d
|
{
|
public:
|
|
/** \param min [in] Minimum point.
|
\param max [in] Maximum point.
|
*/
|
OdGeExtents3d();
|
|
OdGeExtents3d(
|
const OdGePoint3d& min,
|
const OdGePoint3d& max);
|
|
/** \details
|
The invalid extents.
|
*/
|
GE_STATIC_EXPORT static const OdGeExtents3d kInvalid;
|
|
/** \details
|
Returns the minimum point of this Extents object.
|
*/
|
const OdGePoint3d& minPoint() const;
|
|
/** \details
|
Returns the maximum point of this Extents object.
|
*/
|
const OdGePoint3d& maxPoint() const;
|
|
/** \details
|
Sets the minimum and maximum points for this Extents object.
|
|
\param min [in] Minimum point.
|
\param max [in] Maximum point.
|
*/
|
void set(
|
const OdGePoint3d& min,
|
const OdGePoint3d& max);
|
|
/** \details
|
Sets the minimum and maximum points for this Extents object to
|
that of the box defined by pt1 and pt2.
|
|
\param pt1 [in] First point.
|
\param pt2 [in] Second point.
|
|
\remarks
|
pt1 and pt2 need only define a box. They need not be the minimum
|
and maximum points of the box.
|
*/
|
void comparingSet(
|
const OdGePoint3d& pt1,
|
const OdGePoint3d& pt2);
|
|
/** \details
|
Updates the extents of this Extents object with the specified point.
|
|
\param point [in] Any 3D point.
|
*/
|
void addPoint(
|
const OdGePoint3d& point);
|
|
/** \details
|
Updates the extents of this Extents object with the specified Extents object.
|
|
\param extents [in] Any 3D Extents object.
|
*/
|
void addExt(
|
const OdGeExtents3d& extents);
|
|
/** \details
|
Returns true if and only if this Extents object contains valid extents.
|
|
\remarks
|
Extents are valid if and only if each member of the minimum extents
|
is less than or equal to the corresponding member of maximum extents.
|
*/
|
inline bool isValidExtents() const
|
{
|
return ( (m_max.x >= m_min.x) && (m_max.y >= m_min.y) && (m_max.z >= m_min.z));
|
}
|
|
/** \details
|
Updates the extents of this Extents object by the specified vector.
|
\param vect [in] Any 3D vector.
|
*/
|
void expandBy(
|
const OdGeVector3d& vect);
|
|
/** \details
|
Applies the 3D transformation matrix to the extents.
|
|
\param xfm [in] 3D transformation matrix.
|
*/
|
void transformBy(
|
const OdGeMatrix3d& xfm);
|
|
/** \details
|
Returns true if and only if this Extents object contains the specified object.
|
|
\param point [in] Any 3D point.
|
\param extents [in] Any 3D Extents object.
|
*/
|
bool contains(
|
const OdGePoint3d& point, const OdGeTol& tol = OdGeContext::gTol) const;
|
|
bool contains(
|
const OdGeExtents3d& extents, const OdGeTol& tol = OdGeContext::gTol) const;
|
|
/** \details
|
Returns true if and only if specified Extents object
|
does not intersect this one.
|
|
\param extents [in] Any 3D Extents object.
|
*/
|
bool isDisjoint(
|
const OdGeExtents3d& extents, const OdGeTol& tol = OdGeContext::gTol) const;
|
|
enum IntersectionStatus
|
{
|
kIntersectUnknown,// Either or both extents are invalid
|
kIntersectNot, // Extents are NOT intersecting
|
kIntersectOpIn, // Operand is completely within this extents
|
kIntersectOpOut, // This extents is completely within operand
|
kIntersectOk // Extents are intersecting, result is returned
|
};
|
|
/** \details
|
Determines the intersection of the specified Extents object with this one,
|
and returns the resulting intersection box.
|
|
\param extents [in] Any 3D Extents object.
|
\param pResult [out] Receives extents of the intersection.
|
|
\remarks
|
pResult object should be created by the caller. Possible return values are as follows.
|
|
@untitled table
|
kIntersectUnknown Either or both extents boxes are invalid
|
kIntersectNot The extents boxes are NOT intersecting
|
kIntersectOpIn The specified Extents object is completely within this one
|
kIntersectOpOut This Extents object is completely within the specified one
|
kIntersectOk The extents boxes are intersecting, and a result is returned
|
|
*/
|
IntersectionStatus intersectWith(const OdGeExtents3d& extents, OdGeExtents3d* pResult = 0) const;
|
|
OdGePoint3d center() const
|
{
|
return m_min + (m_max - m_min) * 0.5;
|
}
|
|
enum Convert2dPlane
|
{
|
kConvert2dPlaneXY = 0x04,
|
kConvert2dPlaneXZ = 0x0C,
|
kConvert2dPlaneYX = 0x01,
|
kConvert2dPlaneYZ = 0x0D,
|
kConvert2dPlaneZX = 0x03,
|
kConvert2dPlaneZY = 0x07
|
};
|
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);
|
}
|
|
protected:
|
OdGePoint3d m_min;
|
OdGePoint3d m_max;
|
};
|
|
// 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)
|
{
|
m_min = min;
|
m_max = max;
|
}
|
|
inline void OdGeExtents3d::comparingSet(const OdGePoint3d& pt1, const OdGePoint3d& pt2)
|
{
|
if(pt1.x > pt2.x)
|
{
|
m_max.x = pt1.x;
|
m_min.x = pt2.x;
|
}
|
else
|
{
|
m_min.x = pt1.x;
|
m_max.x = pt2.x;
|
}
|
if(pt1.y > pt2.y)
|
{
|
m_max.y = pt1.y;
|
m_min.y = pt2.y;
|
}
|
else
|
{
|
m_min.y = pt1.y;
|
m_max.y = pt2.y;
|
}
|
if(pt1.z > pt2.z)
|
{
|
m_max.z = pt1.z;
|
m_min.z = pt2.z;
|
}
|
else
|
{
|
m_min.z = pt1.z;
|
m_max.z = pt2.z;
|
}
|
}
|
|
#define ex_minmax(max, min, val) \
|
if (max < val) max = val;\
|
else if (min > val) min = val;
|
|
inline void OdGeExtents3d::addPoint(const OdGePoint3d& point)
|
{
|
if ((m_max.x < m_min.x) || (m_max.y < m_min.y) || (m_max.z < m_min.z))
|
{
|
m_max = m_min = point;
|
}
|
else
|
{
|
ex_minmax(m_max.x, m_min.x, point.x);
|
ex_minmax(m_max.y, m_min.y, point.y);
|
ex_minmax(m_max.z, m_min.z, point.z);
|
}
|
}
|
#undef ex_minmax
|
|
inline void OdGeExtents3d::addExt(const OdGeExtents3d& extents)
|
{
|
ODA_ASSERT(extents.isValidExtents());
|
|
#if 0
|
addPoint(extents.minPoint());
|
addPoint(extents.maxPoint());
|
#else
|
// Optimization
|
#define ex_minmax(max, min, valMax, valMin) \
|
if (max < valMax) max = valMax; \
|
if (min > valMin) min = valMin;
|
|
if ((m_max.x < m_min.x) || (m_max.y < m_min.y) || (m_max.z < m_min.z))
|
{
|
set(extents.minPoint(), extents.maxPoint());
|
}
|
else
|
{
|
ex_minmax(m_max.x, m_min.x, extents.maxPoint().x, extents.minPoint().x);
|
ex_minmax(m_max.y, m_min.y, extents.maxPoint().y, extents.minPoint().y);
|
ex_minmax(m_max.z, m_min.z, extents.maxPoint().z, extents.minPoint().z);
|
}
|
|
#undef ex_minmax
|
#endif
|
}
|
|
inline void OdGeExtents3d::expandBy(const OdGeVector3d& vect)
|
{
|
ODA_ASSERT(isValidExtents());
|
|
OdGePoint3d p1 = m_min, p2 = m_max;
|
addPoint(p1 + vect);
|
addPoint(p2 + vect);
|
}
|
|
inline void OdGeExtents3d::transformBy(const OdGeMatrix3d& xfm)
|
{
|
ODA_ASSERT(isValidExtents());
|
|
OdGeVector3d d = m_max - m_min;
|
|
m_max = m_min = (xfm * m_min);
|
if(OdNonZero(d.x, 1.e-200))
|
expandBy(xfm * (OdGeVector3d::kXAxis * d.x));
|
if(OdNonZero(d.y, 1.e-200))
|
expandBy(xfm * (OdGeVector3d::kYAxis * d.y));
|
if(OdNonZero(d.z, 1.e-200))
|
expandBy(xfm * (OdGeVector3d::kZAxis * d.z));
|
}
|
|
inline bool OdGeExtents3d::contains(const OdGePoint3d& point, const OdGeTol& tol) const
|
{
|
ODA_ASSERT(isValidExtents());
|
|
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());
|
|
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()));
|
}
|
|
inline bool OdGeExtents3d::isEqualTo(const OdGeExtents3d& extents, const OdGeTol& tol) const
|
{
|
const OdUInt8 bValid = ((isValidExtents()) ? 1 : 0) | ((extents.isValidExtents()) ? 2 : 0);
|
switch (bValid)
|
{
|
// Both invalid
|
case 0: return true;
|
// Both valid
|
case 3: return m_min.isEqualTo(extents.m_min, tol) && m_max.isEqualTo(extents.m_max, tol);
|
}
|
return false;
|
}
|
|
#undef INVALIDEXTENTS
|
|
#include "TD_PackPop.h"
|
|
#endif //_ODGEEXTENTS3D_INCLUDED_
|
