bounding_box.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
 
namespace Kratos
{
 
 
template <typename TPointType>
class BoundingBox
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(BoundingBox);
 
 
    BoundingBox()
    {
        std::fill(GetMinPoint().begin(), GetMinPoint().end(), 0.0);
        std::fill(GetMaxPoint().begin(), GetMaxPoint().end(), 0.0);
    };
 
    BoundingBox(TPointType const& MinPoint, TPointType const& MaxPoint)
    {
        noalias(GetMinPoint().Coordinates()) = MinPoint.Coordinates();
        noalias(GetMaxPoint().Coordinates()) = MaxPoint.Coordinates();
    }
 
    BoundingBox( const BoundingBox &Other) :
        mMinMaxPoints(Other.mMinMaxPoints) {}
 
 
    template<typename TIteratorType>
    BoundingBox(TIteratorType const& itPointsBegin, TIteratorType const& itPointsEnd) 
    {
        Set(itPointsBegin, itPointsEnd);
    }
 
    virtual ~BoundingBox(){}
 
 
    BoundingBox& operator=(BoundingBox const& rOther)
    {
        GetMinPoint() = rOther.GetMinPoint();
        GetMaxPoint() = rOther.GetMaxPoint();
 
        return *this;
    }
 
 
    template<typename TIteratorType>
    void Set(TIteratorType const& itPointsBegin, TIteratorType const& itPointsEnd)
    {
        if (itPointsBegin == itPointsEnd) {
            std::fill(GetMinPoint().begin(), GetMinPoint().end(), 0.0);
            std::fill(GetMaxPoint().begin(), GetMaxPoint().end(), 0.0);
            return;
        }
 
        // Initialize the min and max points to the first point
        auto& r_min_point = GetMinPoint();
        auto& r_max_point = GetMaxPoint();
        const auto& r_coordinates = itPointsBegin->Coordinates();
        for (unsigned int i = 0; i < Dimension; i++) {
            r_min_point[i] = r_coordinates[i];
            r_max_point[i] = r_coordinates[i];
        }
 
        Extend(itPointsBegin, itPointsEnd);
    }
 
    template<typename TIteratorType>
    void Extend(TIteratorType const& itPointsBegin, TIteratorType const& itPointsEnd)
    {
        // Extend the min and max points
        auto& r_min_point = GetMinPoint();
        auto& r_max_point = GetMaxPoint();
        for (TIteratorType it_point = itPointsBegin; it_point != itPointsEnd; it_point++){
            for (unsigned int i = 0; i < Dimension; i++) {
                if ((*it_point)[i] < r_min_point[i]) r_min_point[i] = (*it_point)[i];
                if ((*it_point)[i] > r_max_point[i]) r_max_point[i] = (*it_point)[i];
            }
        }
    }
 
    void Extend(const double Margin)
    {
        // Extend the min and max points
        auto& r_min_point = GetMinPoint();
        auto& r_max_point = GetMaxPoint();
        for (unsigned int i = 0; i < Dimension; i++){
            r_min_point[i] -= Margin;
            r_max_point[i] += Margin;
        }
    }
 
 
    TPointType& GetMinPoint()
    {
        return mMinMaxPoints[0];
    }
 
    TPointType const& GetMinPoint() const
    {
        return mMinMaxPoints[0];
    }
 
    TPointType& GetMaxPoint()
    {
        return mMinMaxPoints[1];
    }
 
    TPointType const& GetMaxPoint() const 
    {
        return mMinMaxPoints[1];
    }
 
 
 
    virtual std::string Info() const
    {
        std::stringstream buffer;
        buffer << "BoundingBox" ;
        return buffer.str();
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const {rOStream << "BoundingBox";}
 
    virtual void PrintData(std::ostream& rOStream) const {
        rOStream << "   MinPoint : [" << GetMinPoint()[0] << ","  << GetMinPoint()[1] << ","  << GetMinPoint()[2] << "]" << std::endl;
        rOStream << "   MaxPoint : [" << GetMaxPoint()[0] << ","  << GetMaxPoint()[1] << ","  << GetMaxPoint()[2] << "]" << std::endl;
    }
 
 
private:
 
    static constexpr unsigned int Dimension = 3;
 
 
    std::array<TPointType, 2> mMinMaxPoints;  
 
 
}; // Class BoundingBox
 
 
 
template <typename TPointType>
inline std::istream& operator >> (std::istream& rIStream,
                BoundingBox<TPointType>& rThis){
                    return rIStream;
                }
 
template <typename TPointType>
inline std::ostream& operator << (std::ostream& rOStream,
                const BoundingBox<TPointType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.