1097 lines
37 KiB
C++
1097 lines
37 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2005 Imetric 3D GmbH *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
|
|
#ifndef BASE_BOUNDBOX_H
|
|
#define BASE_BOUNDBOX_H
|
|
|
|
#include <array>
|
|
#include <limits>
|
|
#include "Matrix.h"
|
|
#include "Tools2D.h"
|
|
#include "ViewProj.h"
|
|
|
|
|
|
namespace Base {
|
|
|
|
class ViewProjMethod;
|
|
|
|
/** The 3D bounding box class. */
|
|
template <class Precision>
|
|
class BoundBox3
|
|
{
|
|
// helper function
|
|
static bool isOnRayW(Precision min, Precision max, Precision val);
|
|
static bool isOnRayS(Precision min, Precision max, Precision val);
|
|
|
|
public:
|
|
using num_type = Precision;
|
|
using traits_type = float_traits<num_type>;
|
|
|
|
/** Public attributes */
|
|
//@{
|
|
Precision MinX;
|
|
Precision MinY;
|
|
Precision MinZ;
|
|
Precision MaxX;
|
|
Precision MaxY;
|
|
Precision MaxZ;
|
|
//@}
|
|
|
|
/** Builds box from pairs of x,y,z values. */
|
|
inline explicit BoundBox3 (Precision fMinX = std::numeric_limits<Precision>::max(),
|
|
Precision fMinY = std::numeric_limits<Precision>::max(),
|
|
Precision fMinZ = std::numeric_limits<Precision>::max(),
|
|
Precision fMaxX = -std::numeric_limits<Precision>::max(),
|
|
Precision fMaxY = -std::numeric_limits<Precision>::max(),
|
|
Precision fMaxZ = -std::numeric_limits<Precision>::max());
|
|
BoundBox3 (const BoundBox3<Precision> &rcBB) = default;
|
|
BoundBox3 (BoundBox3<Precision> &&rcBB) noexcept = default;
|
|
/** Builds box from an array of points. */
|
|
inline BoundBox3 (const Vector3<Precision> *pclVect, std::size_t ulCt);
|
|
|
|
/** Defines a bounding box around the center \a rcCnt with the
|
|
* distances \a fDistance in each coordinate.
|
|
*/
|
|
BoundBox3 (const Vector3<Precision>& point, Precision distance);
|
|
~BoundBox3 ();
|
|
|
|
/// Assignment operator
|
|
inline BoundBox3<Precision>& operator = (const BoundBox3<Precision> &rcBound) = default;
|
|
inline BoundBox3<Precision>& operator = (BoundBox3<Precision> &&rcBound) noexcept = default;
|
|
|
|
/** Methods for intersection, cuttíng and union of bounding boxes */
|
|
//@{
|
|
/** Checks for intersection. */
|
|
inline bool Intersect (const BoundBox3<Precision> &rcBB) const;
|
|
/** Checks for intersection. */
|
|
inline bool operator && (const BoundBox3<Precision> &rcBB) const;
|
|
/** Checks for intersection. */
|
|
inline bool Intersect (const BoundBox2d &rcBB) const;
|
|
/** Checks for intersection. */
|
|
inline bool operator && (const BoundBox2d &rcBB) const;
|
|
/** Computes the intersection between two bounding boxes.
|
|
* The result is also a bounding box.
|
|
*/
|
|
BoundBox3<Precision> Intersected (const BoundBox3<Precision> &rcBB) const;
|
|
/** The union of two bounding boxes. */
|
|
BoundBox3<Precision> United (const BoundBox3<Precision> &rcBB) const;
|
|
/** Appends the point to the box. The box can grow but not shrink. */
|
|
inline void Add (const Vector3<Precision> &rclVect);
|
|
/** Appends the bounding box to this box. The box can grow but not shrink. */
|
|
inline void Add (const BoundBox3<Precision> &rcBB);
|
|
//@}
|
|
|
|
/** Test methods */
|
|
//@{
|
|
/** Checks if this point lies inside the box.
|
|
* @note It's up to the client programmer to make sure that this bounding box is valid.
|
|
*/
|
|
inline bool IsInBox (const Vector3<Precision> &rcVct) const;
|
|
/** Checks if this 3D box lies inside the box.
|
|
* @note It's up to the client programmer to make sure that both bounding boxes are valid.
|
|
*/
|
|
inline bool IsInBox (const BoundBox3<Precision> &rcBB) const;
|
|
/** Checks if this 2D box lies inside the box.
|
|
* @note It's up to the client programmer to make sure that both bounding boxes are valid.
|
|
*/
|
|
inline bool IsInBox (const BoundBox2d &rcbb) const;
|
|
/** Checks whether the bounding box is valid. */
|
|
bool IsValid () const;
|
|
//@}
|
|
|
|
enum OCTANT {OCT_LDB = 0, OCT_RDB, OCT_LUB, OCT_RUB,
|
|
OCT_LDF, OCT_RDF, OCT_LUF, OCT_RUF};
|
|
bool GetOctantFromVector (const Vector3<Precision> &rclVct, OCTANT &rclOctant) const;
|
|
BoundBox3<Precision> CalcOctant (typename BoundBox3<Precision>::OCTANT Octant) const;
|
|
|
|
enum SIDE { LEFT =0, RIGHT=1, TOP=2, BOTTOM=3, FRONT=4, BACK=5, INVALID=255 };
|
|
enum CORNER {
|
|
TLB = 0, // top-left-back
|
|
TLF = 1, // top-left-front
|
|
TRF = 2, // top-right-front
|
|
TRB = 3, // top-right-back
|
|
BLB = 4, // bottom-left-back
|
|
BLF = 5, // bottom-left-front
|
|
BRF = 6, // bottom-right-front
|
|
BRB = 7, // bottom-right-back
|
|
};
|
|
enum EDGE {
|
|
TLB_TLF = 0,
|
|
TLF_TRF = 1,
|
|
TRF_TRB = 2,
|
|
TRB_TLB = 3,
|
|
BLB_BLF = 4,
|
|
BLF_BRF = 5,
|
|
BRF_BRB = 6,
|
|
BRB_BLB = 7,
|
|
TLB_BLB = 8,
|
|
TLF_BLF = 9,
|
|
TRF_BRF = 10,
|
|
TRB_BRB = 11
|
|
};
|
|
|
|
/**
|
|
* Returns the corner point \a usPoint.
|
|
*/
|
|
inline Vector3<Precision> CalcPoint (unsigned short usPoint) const;
|
|
/** Returns the plane of the given side. */
|
|
void CalcPlane (unsigned short usPlane, Vector3<Precision>& rBase,
|
|
Vector3<Precision>& rNormal) const;
|
|
/** Calculates the two points of an edge.
|
|
*/
|
|
bool CalcEdge (unsigned short usEdge, Vector3<Precision>& rcP0, Vector3<Precision>& rcP1) const;
|
|
/** Intersection point of an inner search ray with the bounding box, built of
|
|
* the base \a rcVct and the direction \a rcVctDir. \a rcVct must lie inside the
|
|
* bounding box.
|
|
*/
|
|
bool IntersectionPoint (const Vector3<Precision> &rcVct,
|
|
const Vector3<Precision> &rcVctDir,
|
|
Vector3<Precision>& cVctRes,
|
|
Precision epsilon) const;
|
|
/** Checks for intersection with line incl. search tolerance. */
|
|
bool IsCutLine (const Vector3<Precision>& rcBase,
|
|
const Vector3<Precision>& rcDir,
|
|
Precision fTolerance = 0.0F) const;
|
|
/** Checks if this plane specified by (point,normal) cuts this box.
|
|
* @note It's up to the client programmer to make sure that this bounding box is valid.
|
|
*/
|
|
inline bool IsCutPlane (const Vector3<Precision> &rclBase,
|
|
const Vector3<Precision> &rclNormal) const;
|
|
/** Computes the intersection points of line and bounding box. */
|
|
bool IntersectWithLine (const Vector3<Precision>& rcBase,
|
|
const Vector3<Precision>& rcDir,
|
|
Vector3<Precision>& rcP0,
|
|
Vector3<Precision>& rcP1) const;
|
|
/** Computes the intersection point of line and a plane of the bounding box. */
|
|
bool IntersectPlaneWithLine (unsigned short usSide,
|
|
const Vector3<Precision>& rcBase,
|
|
const Vector3<Precision>& rcDir,
|
|
Vector3<Precision>& rcP0) const;
|
|
/** Returns the side of the bounding box the ray exits. */
|
|
typename BoundBox3<Precision>::SIDE GetSideFromRay (const Vector3<Precision> &rclPt,
|
|
const Vector3<Precision> &rclDir) const;
|
|
/** Returns the side of the bounding box the ray exits. */
|
|
typename BoundBox3<Precision>::SIDE GetSideFromRay (const Vector3<Precision> &rclPt,
|
|
const Vector3<Precision> &rclDir,
|
|
Vector3<Precision>& rcInt) const;
|
|
|
|
/**
|
|
* Searches for the closest point of the bounding box.
|
|
*/
|
|
Vector3<Precision> ClosestPoint (const Vector3<Precision> &rclPt) const;
|
|
/** Projects the box onto a plane and returns a 2D box. */
|
|
BoundBox2d ProjectBox(const ViewProjMethod* proj) const;
|
|
/** Transform the corners of this box with the given matrix and create a new bounding box.
|
|
* @note It's up to the client programmer to make sure that this bounding box is valid.
|
|
*/
|
|
BoundBox3<Precision> Transformed(const Matrix4D& mat) const;
|
|
|
|
/** Returns the center of the box. */
|
|
inline Vector3<Precision> GetCenter () const;
|
|
/** Returns the minimum point of the box. */
|
|
inline Vector3<Precision> GetMinimum () const;
|
|
/** Returns the maximum point of the box. */
|
|
inline Vector3<Precision> GetMaximum () const;
|
|
/** Compute the diagonal length of this bounding box.
|
|
* @note It's up to the client programmer to make sure that this bounding box is valid.
|
|
*/
|
|
inline Precision CalcDiagonalLength () const;
|
|
void SetVoid ();
|
|
|
|
/** Enlarges the box with \a fLen. */
|
|
inline void Enlarge (Precision fLen);
|
|
/** Shrinks the box with \a fLen. */
|
|
inline void Shrink (Precision fLen);
|
|
|
|
/** Calculates expansion in x-direction. */
|
|
inline Precision LengthX () const;
|
|
/** Calculates expansion in y-direction. */
|
|
inline Precision LengthY () const;
|
|
/** Calculates expansion in z-direction. */
|
|
inline Precision LengthZ () const;
|
|
/** Calculates the volume. If the box is invalid a negative value is returned */
|
|
inline Precision Volume () const;
|
|
/** Moves in x-direction. */
|
|
inline void MoveX (Precision value);
|
|
/** Moves in y-direction. */
|
|
inline void MoveY (Precision value);
|
|
/** Moves in z-direction. */
|
|
inline void MoveZ (Precision value);
|
|
/** Scales in x-direction. */
|
|
inline void ScaleX (Precision value);
|
|
/** Scales in y-direction. */
|
|
inline void ScaleY (Precision value);
|
|
/** Scales in z-direction. */
|
|
inline void ScaleZ (Precision value);
|
|
|
|
/** Prints the values to stream. */
|
|
void Print (std::ostream&) const;
|
|
};
|
|
|
|
|
|
template <class Precision>
|
|
bool BoundBox3<Precision>::isOnRayW(Precision min, Precision max, Precision val)
|
|
{
|
|
// Checks if point val lies on the ray [min,max]
|
|
return ((min <= val) && (val <= max));
|
|
}
|
|
|
|
template <class Precision>
|
|
bool BoundBox3<Precision>::isOnRayS(Precision min, Precision max, Precision val)
|
|
{
|
|
// Checks if point val lies on the ray [min,max[
|
|
return ((min <= val) && (val < max));
|
|
}
|
|
|
|
// NOLINTBEGIN(bugprone-easily-swappable-parameters)
|
|
template <class Precision>
|
|
inline BoundBox3<Precision>::BoundBox3 (Precision fMinX, Precision fMinY, Precision fMinZ,
|
|
Precision fMaxX, Precision fMaxY, Precision fMaxZ)
|
|
: MinX(fMinX), MinY(fMinY), MinZ(fMinZ),
|
|
MaxX(fMaxX), MaxY(fMaxY), MaxZ(fMaxZ)
|
|
{
|
|
}
|
|
// NOLINTEND(bugprone-easily-swappable-parameters)
|
|
|
|
template <class Precision>
|
|
inline BoundBox3<Precision>::BoundBox3 (const Vector3<Precision> *pclVect, std::size_t ulCt)
|
|
: MinX( std::numeric_limits<Precision>::max())
|
|
, MinY( std::numeric_limits<Precision>::max())
|
|
, MinZ( std::numeric_limits<Precision>::max())
|
|
, MaxX(-std::numeric_limits<Precision>::max())
|
|
, MaxY(-std::numeric_limits<Precision>::max())
|
|
, MaxZ(-std::numeric_limits<Precision>::max())
|
|
{
|
|
const Vector3<Precision> *pI = nullptr;
|
|
const Vector3<Precision> *pEnd = pclVect + ulCt;
|
|
for (pI = pclVect; pI < pEnd; ++pI) {
|
|
MinX = std::min<Precision>(MinX, pI->x);
|
|
MinY = std::min<Precision>(MinY, pI->y);
|
|
MinZ = std::min<Precision>(MinZ, pI->z);
|
|
MaxX = std::max<Precision>(MaxX, pI->x);
|
|
MaxY = std::max<Precision>(MaxY, pI->y);
|
|
MaxZ = std::max<Precision>(MaxZ, pI->z);
|
|
}
|
|
}
|
|
|
|
template <class Precision>
|
|
inline BoundBox3<Precision>::BoundBox3 (const Vector3<Precision>& point, Precision distance)
|
|
: MinX(point.x - distance)
|
|
, MinY(point.y - distance)
|
|
, MinZ(point.z - distance)
|
|
, MaxX(point.x + distance)
|
|
, MaxY(point.y + distance)
|
|
, MaxZ(point.z + distance)
|
|
{
|
|
}
|
|
|
|
template <class Precision>
|
|
inline BoundBox3<Precision>::~BoundBox3 () = default;
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::Intersect (const BoundBox3<Precision> &rcBB) const
|
|
{
|
|
if (rcBB.MaxX < this->MinX || rcBB.MinX > this->MaxX) {
|
|
return false;
|
|
}
|
|
if (rcBB.MaxY < this->MinY || rcBB.MinY > this->MaxY) {
|
|
return false;
|
|
}
|
|
if (rcBB.MaxZ < this->MinZ || rcBB.MinZ > this->MaxZ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
bool BoundBox3<Precision>::operator && (const BoundBox3<Precision> &rcBB) const
|
|
{
|
|
return Intersect(rcBB);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::Intersect (const BoundBox2d &rcBB) const
|
|
{
|
|
if (rcBB.MaxX < this->MinX || rcBB.MinX > this->MaxX) {
|
|
return false;
|
|
}
|
|
if (rcBB.MaxY < this->MinY || rcBB.MinY > this->MaxY) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::operator && (const BoundBox2d &rcBB) const
|
|
{
|
|
return Intersect(rcBB);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline BoundBox3<Precision>
|
|
BoundBox3<Precision>::Intersected(const BoundBox3<Precision> &rcBB) const
|
|
{
|
|
BoundBox3<Precision> cBBRes;
|
|
|
|
cBBRes.MinX = std::max<Precision> (MinX, rcBB.MinX);
|
|
cBBRes.MaxX = std::min<Precision> (MaxX, rcBB.MaxX);
|
|
cBBRes.MinY = std::max<Precision> (MinY, rcBB.MinY);
|
|
cBBRes.MaxY = std::min<Precision> (MaxY, rcBB.MaxY);
|
|
cBBRes.MinZ = std::max<Precision> (MinZ, rcBB.MinZ);
|
|
cBBRes.MaxZ = std::min<Precision> (MaxZ, rcBB.MaxZ);
|
|
|
|
return cBBRes;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline BoundBox3<Precision> BoundBox3<Precision>::United(const BoundBox3<Precision> &rcBB) const
|
|
{
|
|
BoundBox3<Precision> cBBRes;
|
|
|
|
cBBRes.MinX = std::min<Precision> (MinX, rcBB.MinX);
|
|
cBBRes.MaxX = std::max<Precision> (MaxX, rcBB.MaxX);
|
|
cBBRes.MinY = std::min<Precision> (MinY, rcBB.MinY);
|
|
cBBRes.MaxY = std::max<Precision> (MaxY, rcBB.MaxY);
|
|
cBBRes.MinZ = std::min<Precision> (MinZ, rcBB.MinZ);
|
|
cBBRes.MaxZ = std::max<Precision> (MaxZ, rcBB.MaxZ);
|
|
|
|
return cBBRes;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::Add (const Vector3<Precision> &rclVect)
|
|
{
|
|
this->MinX = std::min<Precision>(this->MinX, rclVect.x);
|
|
this->MinY = std::min<Precision>(this->MinY, rclVect.y);
|
|
this->MinZ = std::min<Precision>(this->MinZ, rclVect.z);
|
|
this->MaxX = std::max<Precision>(this->MaxX, rclVect.x);
|
|
this->MaxY = std::max<Precision>(this->MaxY, rclVect.y);
|
|
this->MaxZ = std::max<Precision>(this->MaxZ, rclVect.z);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::Add (const BoundBox3<Precision> &rcBB)
|
|
{
|
|
this->MinX = std::min<Precision> (this->MinX, rcBB.MinX);
|
|
this->MaxX = std::max<Precision> (this->MaxX, rcBB.MaxX);
|
|
this->MinY = std::min<Precision> (this->MinY, rcBB.MinY);
|
|
this->MaxY = std::max<Precision> (this->MaxY, rcBB.MaxY);
|
|
this->MinZ = std::min<Precision> (this->MinZ, rcBB.MinZ);
|
|
this->MaxZ = std::max<Precision> (this->MaxZ, rcBB.MaxZ);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IsInBox (const Vector3<Precision> &rcVct) const
|
|
{
|
|
if (rcVct.x < this->MinX || rcVct.x > this->MaxX) {
|
|
return false;
|
|
}
|
|
if (rcVct.y < this->MinY || rcVct.y > this->MaxY) {
|
|
return false;
|
|
}
|
|
if (rcVct.z < this->MinZ || rcVct.z > this->MaxZ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IsInBox (const BoundBox3<Precision> &rcBB) const
|
|
{
|
|
if (rcBB.MinX < this->MinX || rcBB.MaxX > this->MaxX) {
|
|
return false;
|
|
}
|
|
if (rcBB.MinY < this->MinY || rcBB.MaxY > this->MaxY) {
|
|
return false;
|
|
}
|
|
if (rcBB.MinZ < this->MinZ || rcBB.MaxZ > this->MaxZ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IsInBox (const BoundBox2d &rcBB) const
|
|
{
|
|
if (rcBB.MinX < this->MinX || rcBB.MaxX > this->MaxX) {
|
|
return false;
|
|
}
|
|
if (rcBB.MinY < this->MinY || rcBB.MaxY > this->MaxY) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IsValid () const
|
|
{
|
|
return ((MinX <= MaxX) && (MinY <= MaxY) && (MinZ <= MaxZ));
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::GetOctantFromVector (const Vector3<Precision> &rclVct,
|
|
OCTANT &rclOctant) const
|
|
{
|
|
if (!IsInBox (rclVct)) {
|
|
return false;
|
|
}
|
|
|
|
unsigned short usNdx = 0;
|
|
if (isOnRayS ((MinX + MaxX)/2, MaxX, rclVct.x)) { // left/RIGHT
|
|
usNdx |= 1;
|
|
}
|
|
if (isOnRayS ((MinY + MaxY)/2, MaxY, rclVct.y)) { // down/UP
|
|
usNdx |= 2;
|
|
}
|
|
if (isOnRayS ((MinZ + MaxZ)/2, MaxZ, rclVct.z)) { // back/FRONT
|
|
usNdx |= 4;
|
|
}
|
|
rclOctant = static_cast<OCTANT>(usNdx);
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline BoundBox3<Precision>
|
|
BoundBox3<Precision>::CalcOctant (typename BoundBox3< Precision >::OCTANT Octant) const
|
|
{
|
|
BoundBox3<Precision> cOct (*this);
|
|
|
|
switch (Octant) {
|
|
case OCT_LDB:
|
|
cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
|
|
case OCT_RDB:
|
|
cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
|
|
case OCT_LUB:
|
|
cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
|
|
case OCT_RUB:
|
|
cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
|
|
case OCT_LDF:
|
|
cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
|
|
case OCT_RDF:
|
|
cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
|
|
case OCT_LUF:
|
|
cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
|
|
case OCT_RUF:
|
|
cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
|
|
cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
|
|
cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
|
|
break;
|
|
}
|
|
return cOct;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Vector3<Precision> BoundBox3<Precision>::CalcPoint (unsigned short usPoint) const
|
|
{
|
|
switch (usPoint) {
|
|
case TLB: return Vector3<Precision>(MinX, MinY, MaxZ);
|
|
case TLF: return Vector3<Precision>(MaxX, MinY, MaxZ);
|
|
case TRF: return Vector3<Precision>(MaxX, MaxY, MaxZ);
|
|
case TRB: return Vector3<Precision>(MinX, MaxY, MaxZ);
|
|
case BLB: return Vector3<Precision>(MinX, MinY, MinZ);
|
|
case BLF: return Vector3<Precision>(MaxX, MinY, MinZ);
|
|
case BRF: return Vector3<Precision>(MaxX, MaxY, MinZ);
|
|
case BRB: return Vector3<Precision>(MinX, MaxY, MinZ);
|
|
}
|
|
|
|
return Vector3<Precision>();
|
|
}
|
|
|
|
// NOLINTBEGIN(bugprone-easily-swappable-parameters)
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::CalcPlane (unsigned short usPlane,
|
|
Vector3<Precision>& rBase,
|
|
Vector3<Precision>& rNormal) const
|
|
// NOLINTEND(bugprone-easily-swappable-parameters)
|
|
{
|
|
switch (usPlane) {
|
|
case LEFT:
|
|
rBase.Set(MinX, MinY, MaxZ);
|
|
rNormal.Set(1.0F, 0.0F, 0.0F);
|
|
break;
|
|
|
|
case RIGHT:
|
|
rBase.Set(MaxX, MinY, MaxZ);
|
|
rNormal.Set(1.0F, 0.0F, 0.0F);
|
|
break;
|
|
|
|
case TOP:
|
|
rBase.Set(MinX, MaxY, MaxZ);
|
|
rNormal.Set(0.0F, 1.0F, 0.0F);
|
|
break;
|
|
|
|
case BOTTOM:
|
|
rBase.Set(MinX, MinY, MaxZ);
|
|
rNormal.Set(0.0F, 1.0F, 0.0F);
|
|
break;
|
|
|
|
case FRONT:
|
|
rBase.Set(MinX, MinY, MaxZ);
|
|
rNormal.Set(0.0F, 0.0F, 1.0F);
|
|
break;
|
|
|
|
case BACK:
|
|
rBase.Set(MinX, MinY, MinZ);
|
|
rNormal.Set(0.0F, 0.0F, 1.0F);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::CalcEdge (unsigned short usEdge, Vector3<Precision>& rcP0,
|
|
Vector3<Precision>& rcP1) const
|
|
{
|
|
switch (usEdge) {
|
|
case TLB_TLF:
|
|
rcP0 = CalcPoint(TLB);
|
|
rcP1 = CalcPoint(TLF);
|
|
break;
|
|
case TLF_TRF:
|
|
rcP0 = CalcPoint(TLF);
|
|
rcP1 = CalcPoint(TRF);
|
|
break;
|
|
case TRF_TRB:
|
|
rcP0 = CalcPoint(TRF);
|
|
rcP1 = CalcPoint(TRB);
|
|
break;
|
|
case TRB_TLB:
|
|
rcP0 = CalcPoint(TRB);
|
|
rcP1 = CalcPoint(TLB);
|
|
break;
|
|
case BLB_BLF:
|
|
rcP0 = CalcPoint(BLB);
|
|
rcP1 = CalcPoint(BLF);
|
|
break;
|
|
case BLF_BRF:
|
|
rcP0 = CalcPoint(BLF);
|
|
rcP1 = CalcPoint(BRF);
|
|
break;
|
|
case BRF_BRB:
|
|
rcP0 = CalcPoint(BRF);
|
|
rcP1 = CalcPoint(BRB);
|
|
break;
|
|
case BRB_BLB:
|
|
rcP0 = CalcPoint(BRB);
|
|
rcP1 = CalcPoint(BLB);
|
|
break;
|
|
case TLB_BLB:
|
|
rcP0 = CalcPoint(TLB);
|
|
rcP1 = CalcPoint(BLB);
|
|
break;
|
|
case TLF_BLF:
|
|
rcP0 = CalcPoint(TLF);
|
|
rcP1 = CalcPoint(BLF);
|
|
break;
|
|
case TRF_BRF:
|
|
rcP0 = CalcPoint(TRF);
|
|
rcP1 = CalcPoint(BRF);
|
|
break;
|
|
case TRB_BRB:
|
|
rcP0 = CalcPoint(TRB);
|
|
rcP1 = CalcPoint(BRB);
|
|
break;
|
|
default:
|
|
return false; // undefined
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IntersectionPoint (const Vector3<Precision> &rcVct,
|
|
const Vector3<Precision> &rcVctDir,
|
|
Vector3<Precision>& cVctRes,
|
|
Precision epsilon) const
|
|
{
|
|
const unsigned short num = 6;
|
|
bool rc=false;
|
|
BoundBox3<Precision> cCmpBound(*this);
|
|
|
|
// enlarge bounding box by epsilon
|
|
cCmpBound.Enlarge(epsilon);
|
|
|
|
// Is point inside?
|
|
if (cCmpBound.IsInBox (rcVct)) {
|
|
// test sides
|
|
for (unsigned short i = 0; (i < num) && (!rc); i++) {
|
|
rc = IntersectPlaneWithLine(i, rcVct, rcVctDir, cVctRes);
|
|
|
|
if (!cCmpBound.IsInBox(cVctRes)) {
|
|
rc = false;
|
|
}
|
|
|
|
if (rc) {
|
|
// does intersection point lie in desired direction
|
|
// or was found the opposing side?
|
|
// -> scalar product of both direction vectors > 0 (angle < 90)
|
|
rc = ((cVctRes - rcVct) * rcVctDir) >= 0.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IsCutLine (const Vector3<Precision>& rcBase,
|
|
const Vector3<Precision>& rcDir,
|
|
Precision fTolerance) const
|
|
{
|
|
const unsigned short num = 6;
|
|
Precision fDist;
|
|
|
|
// at first only a rough and quick test by the
|
|
// Distance of the line to the center of the BB is calculated
|
|
// and with the maximum diagonal length + fTolerance
|
|
// will be compared.
|
|
|
|
// Distance between center point and line
|
|
fDist = (rcDir % (GetCenter() - rcBase)).Length() / rcDir.Length();
|
|
|
|
if (fDist > (CalcDiagonalLength() + fTolerance)) {
|
|
return false;
|
|
}
|
|
|
|
// more detailed test here
|
|
Vector3<Precision> clVectRes;
|
|
|
|
// intersect each face with the line
|
|
for (unsigned short i = 0; i < num; i++) {
|
|
if (IntersectPlaneWithLine(i, rcBase, rcDir, clVectRes)) {
|
|
// Check whether the intersection point is within BB limits + Tolerance
|
|
switch (i) {
|
|
case LEFT : // left and right plane
|
|
case RIGHT :
|
|
if ((isOnRayW (MinY - fTolerance, MaxY + fTolerance, clVectRes.y) &&
|
|
isOnRayW (MinZ - fTolerance, MaxZ + fTolerance, clVectRes.z))) {
|
|
return true;
|
|
}
|
|
break;
|
|
case TOP : // top and bottom plane
|
|
case BOTTOM :
|
|
if ((isOnRayW (MinX - fTolerance, MaxX + fTolerance, clVectRes.x) &&
|
|
isOnRayW (MinZ - fTolerance, MaxZ + fTolerance, clVectRes.z))) {
|
|
return true;
|
|
}
|
|
break;
|
|
case FRONT : // front and back plane
|
|
case BACK :
|
|
if ((isOnRayW (MinX - fTolerance, MaxX + fTolerance, clVectRes.x) &&
|
|
isOnRayW (MinY - fTolerance, MaxY + fTolerance, clVectRes.y))) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IsCutPlane (const Vector3<Precision> &rclBase,
|
|
const Vector3<Precision> &rclNormal) const
|
|
{
|
|
const unsigned short num = 8;
|
|
if (fabs(GetCenter().DistanceToPlane(rclBase, rclNormal)) < CalcDiagonalLength()) {
|
|
Precision fD = CalcPoint(CORNER::TLB).DistanceToPlane(rclBase, rclNormal);
|
|
for (unsigned short i = 1; i < num; i++) {
|
|
if ((CalcPoint(i).DistanceToPlane(rclBase, rclNormal) * fD) <= 0.0F) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// NOLINTBEGIN(bugprone-easily-swappable-parameters)
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IntersectWithLine (const Vector3<Precision> & rcBase,
|
|
const Vector3<Precision>& rcDir,
|
|
Vector3<Precision>& rcP0,
|
|
Vector3<Precision>& rcP1) const
|
|
// NOLINTEND(bugprone-easily-swappable-parameters)
|
|
{
|
|
const unsigned short num = 6;
|
|
Vector3<Precision> clVectRes;
|
|
std::array<Vector3<Precision>, num> clVect;
|
|
unsigned short numIntersect = 0;
|
|
|
|
auto checkIntersect = [&](Base::Vector3<Precision> p1,
|
|
Base::Vector3<Precision> p2) {
|
|
if (isOnRayS(p1.x, p1.y, p1.z) && isOnRayS(p2.x, p2.y, p2.z)) {
|
|
clVect[numIntersect] = clVectRes;
|
|
numIntersect++;
|
|
}
|
|
};
|
|
|
|
// cut each face with the line
|
|
for (unsigned short i = 0; i < num; i++) {
|
|
if (IntersectPlaneWithLine(i, rcBase, rcDir, clVectRes)) {
|
|
// check if intersection point is inside
|
|
switch (i) {
|
|
case LEFT : // left and right plane
|
|
case RIGHT :
|
|
checkIntersect(Vector3<Precision>{MinY, MaxY, clVectRes.y},
|
|
Vector3<Precision>{MinZ, MaxZ, clVectRes.z});
|
|
break;
|
|
case TOP : // top and bottom plane
|
|
case BOTTOM :
|
|
checkIntersect(Vector3<Precision>{MinX, MaxX, clVectRes.x},
|
|
Vector3<Precision>{MinZ, MaxZ, clVectRes.z});
|
|
break;
|
|
case FRONT : // front and back plane
|
|
case BACK :
|
|
checkIntersect(Vector3<Precision>{MinX, MaxX, clVectRes.x},
|
|
Vector3<Precision>{MinY, MaxY, clVectRes.y});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (numIntersect == 2) {
|
|
rcP0 = clVect[0];
|
|
rcP1 = clVect[1];
|
|
return true;
|
|
}
|
|
|
|
if (numIntersect > 2) { // search two different intersection points
|
|
for (unsigned short i = 1; i < numIntersect; i++) {
|
|
if (clVect[i] != clVect[0]) {
|
|
rcP0 = clVect[0];
|
|
rcP1 = clVect[i];
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// NOLINTBEGIN(bugprone-easily-swappable-parameters)
|
|
template <class Precision>
|
|
inline bool BoundBox3<Precision>::IntersectPlaneWithLine (unsigned short usSide,
|
|
const Vector3<Precision>& rcBase,
|
|
const Vector3<Precision>& rcDir,
|
|
Vector3<Precision>& rcP0) const
|
|
// NOLINTEND(bugprone-easily-swappable-parameters)
|
|
{
|
|
Precision value;
|
|
Vector3<Precision> cBase;
|
|
Vector3<Precision> cNormal;
|
|
Vector3<Precision> cDir(rcDir);
|
|
CalcPlane(usSide, cBase, cNormal);
|
|
|
|
if ((cNormal * cDir) == 0.0F) {
|
|
return false; // no point of intersection
|
|
}
|
|
|
|
value = (cNormal * (cBase - rcBase)) / (cNormal * cDir);
|
|
cDir.Scale(value, value, value);
|
|
rcP0 = rcBase + cDir;
|
|
return true;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline typename BoundBox3<Precision>::SIDE
|
|
BoundBox3<Precision>::GetSideFromRay (const Vector3<Precision> &rclPt,
|
|
const Vector3<Precision> &rclDir) const
|
|
{
|
|
Vector3<Precision> cIntersection;
|
|
return GetSideFromRay( rclPt, rclDir, cIntersection);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline typename BoundBox3<Precision>::SIDE
|
|
BoundBox3<Precision>::GetSideFromRay (const Vector3<Precision> &rclPt,
|
|
const Vector3<Precision> &rclDir,
|
|
Vector3<Precision>& rcInt) const
|
|
{
|
|
Vector3<Precision> cP0;
|
|
Vector3<Precision> cP1;
|
|
if (!IntersectWithLine(rclPt, rclDir, cP0, cP1)) {
|
|
return INVALID;
|
|
}
|
|
|
|
Vector3<Precision> cOut;
|
|
// same orientation
|
|
if ((cP1-cP0)*rclDir > 0) {
|
|
cOut = cP1;
|
|
}
|
|
else {
|
|
cOut = cP0;
|
|
}
|
|
|
|
rcInt = cOut;
|
|
|
|
Precision fMax = 1.0e-3F; //NOLINT
|
|
SIDE tSide = INVALID;
|
|
|
|
if (fabs(cOut.x - MinX) < fMax) { // left plane
|
|
fMax = Precision(fabs(cOut.x - MinX));
|
|
tSide = LEFT;
|
|
}
|
|
|
|
if (fabs(cOut.x - MaxX) < fMax) { // right plane
|
|
fMax = Precision(fabs(cOut.x - MaxX));
|
|
tSide = RIGHT;
|
|
}
|
|
|
|
if (fabs(cOut.y - MinY) < fMax) { // bottom plane
|
|
fMax = Precision(fabs(cOut.y - MinY));
|
|
tSide = BOTTOM;
|
|
}
|
|
|
|
if (fabs(cOut.y - MaxY) < fMax) { // top plane
|
|
fMax = Precision(fabs(cOut.y - MaxY));
|
|
tSide = TOP;
|
|
}
|
|
|
|
if (fabs(cOut.z - MinZ) < fMax) { // front plane
|
|
fMax = Precision(fabs(cOut.z - MinZ));
|
|
tSide = FRONT;
|
|
}
|
|
|
|
if (fabs(cOut.z - MaxZ) < fMax) { // back plane
|
|
fMax = Precision(fabs(cOut.z - MaxZ));
|
|
tSide = BACK;
|
|
}
|
|
|
|
return tSide;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Vector3<Precision> BoundBox3<Precision>::ClosestPoint (const Vector3<Precision> &rclPt) const
|
|
{
|
|
Vector3<Precision> closest = rclPt;
|
|
|
|
Vector3<Precision> center = GetCenter();
|
|
Precision devx = closest.x - center.x;
|
|
Precision devy = closest.y - center.y;
|
|
Precision devz = closest.z - center.z;
|
|
|
|
Precision halfwidth = (MaxX - MinX) / 2;
|
|
Precision halfheight = (MaxY - MinY) / 2;
|
|
Precision halfdepth = (MaxZ - MinZ) / 2;
|
|
|
|
// Move point to be on the nearest plane of the box.
|
|
if ((fabs(devx) > fabs(devy)) && (fabs(devx) > fabs(devz))) {
|
|
closest.x = center.x + halfwidth * ((devx < 0.0) ? -1.0 : 1.0);
|
|
}
|
|
else if (fabs(devy) > fabs(devz)) {
|
|
closest.y = center.y + halfheight * ((devy < 0.0) ? -1.0 : 1.0);
|
|
}
|
|
else {
|
|
closest.z = center.z + halfdepth * ((devz < 0.0) ? -1.0 : 1.0);
|
|
}
|
|
|
|
// Clamp to be inside box.
|
|
closest.x = std::min<Precision>(std::max<Precision>(closest.x, MinX), MaxX);
|
|
closest.y = std::min<Precision>(std::max<Precision>(closest.y, MinY), MaxY);
|
|
closest.z = std::min<Precision>(std::max<Precision>(closest.z, MinZ), MaxZ);
|
|
|
|
return closest;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline BoundBox2d BoundBox3<Precision>::ProjectBox(const ViewProjMethod* proj) const
|
|
{
|
|
const int num = 8;
|
|
BoundBox2d clBB2D;
|
|
clBB2D.SetVoid();
|
|
|
|
for (int i = 0; i < num; i++) {
|
|
Vector3<Precision> clTrsPt = (*proj)(CalcPoint(i));
|
|
clBB2D.Add(Vector2d(clTrsPt.x, clTrsPt.y));
|
|
}
|
|
|
|
return clBB2D;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline BoundBox3<Precision> BoundBox3<Precision>::Transformed(const Matrix4D& mat) const
|
|
{
|
|
const int num = 8;
|
|
BoundBox3<Precision> bbox;
|
|
for (int i = 0; i < num; i++) {
|
|
bbox.Add(mat * CalcPoint(i));
|
|
}
|
|
return bbox;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Vector3<Precision> BoundBox3<Precision>::GetCenter () const
|
|
{
|
|
return Vector3<Precision>((MaxX + MinX) / 2,
|
|
(MaxY + MinY) / 2,
|
|
(MaxZ + MinZ) / 2);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Vector3<Precision> BoundBox3<Precision>::GetMinimum () const
|
|
{
|
|
return Vector3<Precision>(MinX, MinY, MinZ);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Vector3<Precision> BoundBox3<Precision>::GetMaximum () const
|
|
{
|
|
return Vector3<Precision>(MaxX, MaxY, MaxZ);
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Precision BoundBox3<Precision>::CalcDiagonalLength () const
|
|
{
|
|
return static_cast<Precision>(sqrt (((MaxX - MinX) * (MaxX - MinX)) +
|
|
((MaxY - MinY) * (MaxY - MinY)) +
|
|
((MaxZ - MinZ) * (MaxZ - MinZ))));
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::SetVoid ()
|
|
{
|
|
MinX = MinY = MinZ = std::numeric_limits<Precision>::max();
|
|
MaxX = MaxY = MaxZ = -std::numeric_limits<Precision>::max();
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::Enlarge (Precision fLen)
|
|
{
|
|
MinX -= fLen; MinY -= fLen; MinZ -= fLen;
|
|
MaxX += fLen; MaxY += fLen; MaxZ += fLen;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::Shrink (Precision fLen)
|
|
{
|
|
MinX += fLen; MinY += fLen; MinZ += fLen;
|
|
MaxX -= fLen; MaxY -= fLen; MaxZ -= fLen;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Precision BoundBox3<Precision>::LengthX () const
|
|
{
|
|
return MaxX - MinX;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Precision BoundBox3<Precision>::LengthY () const
|
|
{
|
|
return MaxY - MinY;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Precision BoundBox3<Precision>::LengthZ () const
|
|
{
|
|
return MaxZ - MinZ;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline Precision BoundBox3<Precision>::Volume () const
|
|
{
|
|
if (!IsValid()) {
|
|
return -1.0;
|
|
}
|
|
return LengthX() * LengthY() * LengthZ();
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::MoveX (Precision value)
|
|
{
|
|
MinX += value;
|
|
MaxX += value;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::MoveY (Precision value)
|
|
{
|
|
MinY += value;
|
|
MaxY += value;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::MoveZ (Precision value)
|
|
{
|
|
MinZ += value;
|
|
MaxZ += value;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::ScaleX (Precision value)
|
|
{
|
|
MinX *= value;
|
|
MaxX *= value;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::ScaleY (Precision value)
|
|
{
|
|
MinY *= value;
|
|
MaxY *= value;
|
|
}
|
|
|
|
template <class Precision>
|
|
inline void BoundBox3<Precision>::ScaleZ (Precision value)
|
|
{
|
|
MinZ *= value;
|
|
MaxZ *= value;
|
|
}
|
|
|
|
using BoundBox3f = BoundBox3<float>;
|
|
using BoundBox3d = BoundBox3<double>;
|
|
|
|
} // namespace Base
|
|
|
|
#endif // BASE_BOUNDBOX_H
|
|
|