oriented_bounding_box.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#if !defined(OBB_CLASS_H_DEFINED )
#define  OBB_CLASS_H_DEFINED
 
// System includes
#include <iomanip>
 
// External includes
 
// Project includes
#include "geometries/point.h"
#include "includes/node.h"
#include "geometries/geometry.h"
#include "geometries/quadrilateral_2d_4.h"
#include "geometries/hexahedra_3d_8.h"
 
namespace Kratos
{
 
 
 
    enum class OBBHasIntersectionType {Direct = 0, SeparatingAxisTheorem = 1};
 
 
 
template<std::size_t TDim>
class KRATOS_API(KRATOS_CORE) OrientedBoundingBox
{
public:
 
 
    // Node definition
    typedef Node                NodeType;
 
    typedef Geometry<NodeType> GeometryType;
 
    typedef std::size_t           IndexType;
 
    typedef std::size_t            SizeType;
 
    static constexpr double ZeroTolerance = std::numeric_limits<double>::epsilon();
 
    typedef typename std::conditional<TDim == 2, Quadrilateral2D4<Point>, Hexahedra3D8<Point> >::type  OutputType;
 
    KRATOS_CLASS_POINTER_DEFINITION( OrientedBoundingBox );
 
 
    OrientedBoundingBox(
        const array_1d<double, 3>& rCenterCoords,
        const array_1d<array_1d<double, 3>, TDim>& rOrientationVectors,
        const array_1d<double, TDim>& rHalfLength
        );
 
    OrientedBoundingBox(
        const array_1d<double, 3>& rCenterCoords,
        const array_1d<array_1d<double, 3>, TDim>& rAxisCoordinates
        );
 
    OrientedBoundingBox(
        const GeometryType& rGeometry,
        const double BoundingBoxFactor,
        const bool BuildFromBoundingBox = true
        );
 
    OrientedBoundingBox(const OrientedBoundingBox& rhs):
        mPointCenter(rhs.mPointCenter),
        mOrientationVectors(rhs.mOrientationVectors),
        mHalfLength(rhs.mHalfLength)
    {
    }
 
    ~OrientedBoundingBox()
    {
    }
 
 
 
    const array_1d<double, 3>& GetCenter() const;
 
    void SetCenter(const array_1d<double, 3>& rCenterCoords);
 
    const array_1d<array_1d<double, 3>, TDim>& GetOrientationVectors() const;
 
    void SetOrientationVectors(const array_1d<array_1d<double, 3>, TDim>& rOrientationVectors);
 
    const array_1d<double, TDim>& GetHalfLength() const;
 
    void SetHalfLength(const array_1d<double, TDim>& rHalfLength);
 
    bool IsInside(const OrientedBoundingBox& rOtherOrientedBoundingBox) const;
 
    bool HasIntersection(
        const OrientedBoundingBox& rOtherOrientedBoundingBox,
        const OBBHasIntersectionType OBBType = OBBHasIntersectionType::SeparatingAxisTheorem
        ) const;
 
    OutputType GetEquivalentGeometry() const;
 
    void GetEquivalentRotatedGeometry(OutputType& rGeometry);
 
 
 
 
    virtual std::string Info() const
    {
        std::stringstream string_out_coordinates;
        for (std::size_t i = 0; i < TDim; ++i) {
            string_out_coordinates
            << std::setiosflags(std::ios::scientific)
            << std::setprecision(3)
            << std::uppercase
            << "\t" << mPointCenter[i];
        }
 
        std::stringstream string_out_orientation_vectors;
        for (std::size_t i = 0; i < TDim; ++i) {
            string_out_orientation_vectors << "\nThe orientation axis " << i << " is: ";
            for (std::size_t j = 0; j < TDim; ++j) {
                string_out_orientation_vectors
                << std::setiosflags(std::ios::scientific)
                << std::setprecision(3)
                << std::uppercase
                << "\t" << mOrientationVectors[i][j];
            }
        }
 
        std::stringstream string_out_half_length;
        for (std::size_t i = 0; i < TDim; ++i) {
            string_out_half_length
            << std::setiosflags(std::ios::scientific)
            << std::setprecision(3)
            << std::uppercase
            << "\t" << mHalfLength[i];
        }
 
        return "OrientedBoundingBox in " + std::to_string(TDim) + "D space" + "\nWhich center is:" + string_out_coordinates.str() + "\nThe orientation axis are: " + string_out_orientation_vectors.str() + "\nThe half lengths are: " + string_out_half_length.str();
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << Info() << std::endl;
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        rOStream << Info() << std::endl;
    }
 
 
protected:
 
 
 
 
 
 
 
 
private:
 
    array_1d<double, 3> mPointCenter;                        
    array_1d<array_1d<double, 3>, TDim> mOrientationVectors; 
    array_1d<double, TDim> mHalfLength;                      
 
 
 
    bool DirectHasIntersection(const OrientedBoundingBox& rOtherOrientedBoundingBox) const;
 
    bool SeparatingAxisTheoremHasIntersection(const OrientedBoundingBox& rOtherOrientedBoundingBox) const;
 
    bool GetSeparatingPlane(
        const array_1d<double, 3>& rRelativePosition,
        const array_1d<double, 3>& rPlane,
        const OrientedBoundingBox& rOtherOrientedBoundingBox
        ) const;
 
    bool GetSeparatingPlane2D(
        const array_1d<double, 3>& rRelativePosition,
        const array_1d<double, 3>& rPlane,
        const OrientedBoundingBox& rOtherOrientedBoundingBox
        ) const;
 
    bool GetSeparatingPlane3D(
        const array_1d<double, 3>& rRelativePosition,
        const array_1d<double, 3>& rPlane,
        const OrientedBoundingBox& rOtherOrientedBoundingBox
        ) const;
 
    void RotateNode2D(array_1d<double, 3>& rCoords) const;
 
    void RotateNode3D(
        array_1d<double, 3>& rCoords,
        const BoundedMatrix<double, 4, 4>& rInvertedRotationMatrix
        ) const;
 
    bool CheckIsInside2D(array_1d<double, 3>& rCoords) const;
 
    bool CheckIsInside3D(
        array_1d<double, 3>& rCoords,
        BoundedMatrix<double, 4, 4> rInvertedRotationMatrix
        ) const;
 
 
 
 
}; // Class OrientedBoundingBox
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // OBB_CLASS_H_DEFINED  defined