AxisAlignedBoundingBox.h

Go to the documentation of this file.

#ifndef PBAT_GEOMETRY_AXISALIGNEDBOUNDINGBOX_H
#define PBAT_GEOMETRY_AXISALIGNEDBOUNDINGBOX_H
 
#include <Eigen/Geometry>
#include <array>
#include <pbat/Aliases.h>
#include <vector>
 
namespace pbat::geometry {
template <int Dims>
class AxisAlignedBoundingBox : public Eigen::AlignedBox<Scalar, Dims>
{
public:
    using BaseType = Eigen::AlignedBox<Scalar, Dims>; 
    using SelfType = AxisAlignedBoundingBox;          
 
    static auto constexpr kDims = Dims; 
 
    AxisAlignedBoundingBox() = default;

    AxisAlignedBoundingBox(BaseType const& box);
    AxisAlignedBoundingBox(BaseType&& box);
    AxisAlignedBoundingBox& operator=(BaseType const& box);
    AxisAlignedBoundingBox& operator=(BaseType&& box);
    template <class TDerivedMin, class TDerivedMax>
    AxisAlignedBoundingBox(
        Eigen::DenseBase<TDerivedMin> const& min,
        Eigen::DenseBase<TDerivedMax> const& max);
    template <class TDerived>
    AxisAlignedBoundingBox(Eigen::DenseBase<TDerived> const& P);
    template <class TDerived>
    std::vector<Index> contained(Eigen::MatrixBase<TDerived> const& P) const;
};
 
template <int Dims>
inline AxisAlignedBoundingBox<Dims>::AxisAlignedBoundingBox(BaseType const& box)
    : BaseType(box)
{
}
 
template <int Dims>
inline AxisAlignedBoundingBox<Dims>::AxisAlignedBoundingBox(BaseType&& box)
    : BaseType(box)
{
}
 
template <int Dims>
inline AxisAlignedBoundingBox<Dims>& AxisAlignedBoundingBox<Dims>::operator=(BaseType const& box)
{
    BaseType::template operator=(box);
    return *this;
}
 
template <int Dims>
inline AxisAlignedBoundingBox<Dims>& AxisAlignedBoundingBox<Dims>::operator=(BaseType&& box)
{
    BaseType::template operator=(box);
    return *this;
}
 
template <int Dims>
template <class TDerivedMin, class TDerivedMax>
inline AxisAlignedBoundingBox<Dims>::AxisAlignedBoundingBox(
    Eigen::DenseBase<TDerivedMin> const& min,
    Eigen::DenseBase<TDerivedMax> const& max)
    : BaseType(min, max)
{
}
 
template <int Dims>
template <class TDerived>
inline AxisAlignedBoundingBox<Dims>::AxisAlignedBoundingBox(Eigen::DenseBase<TDerived> const& P)
    : BaseType(P.rowwise().minCoeff(), P.rowwise().maxCoeff())
{
}
 
template <int Dims>
template <class TDerived>
inline std::vector<Index>
AxisAlignedBoundingBox<Dims>::contained(Eigen::MatrixBase<TDerived> const& P) const
{
    std::vector<Index> inds{};
    inds.reserve(static_cast<std::size_t>(P.cols()));
    for (auto i = 0; i < P.cols(); ++i)
    {
        if (BaseType::template contains(P.col(i)))
        {
            inds.push_back(static_cast<Index>(i));
        }
    }
    return inds;
}

template <auto kDims, auto kClusterNodes, class FCluster, class TDerivedL, class TDerivedU>
inline void ClustersToAabbs(
    FCluster fCluster,
    Index nClusters,
    Eigen::DenseBase<TDerivedL>& L,
    Eigen::DenseBase<TDerivedU>& U)
{
    using MatrixType = std::invoke_result_t<FCluster, Index>;
    for (auto c = 0; c < nClusters; ++c)
    {
        MatrixType const& XC            = fCluster(c);
        L.col(c).template head<kDims>() = XC.rowwise().minCoeff();
        U.col(c).template head<kDims>() = XC.rowwise().maxCoeff();
    }
}

template <auto kDims, auto kClusterNodes, class FCluster, class TDerivedB>
inline void ClustersToAabbs(FCluster fCluster, Index nClusters, Eigen::DenseBase<TDerivedB>& B)
{
    using MatrixType = std::invoke_result_t<FCluster, Index>;
    for (auto c = 0; c < nClusters; ++c)
    {
        MatrixType const& XC            = fCluster(c);
        B.col(c).template head<kDims>() = XC.rowwise().minCoeff();
        B.col(c).template tail<kDims>() = XC.rowwise().maxCoeff();
    }
}

template <
    auto kDims,
    auto kElemNodes,
    class TDerivedX,
    class TDerivedE,
    class TDerivedL,
    class TDerivedU>
inline void MeshToAabbs(
    Eigen::DenseBase<TDerivedX> const& X,
    Eigen::DenseBase<TDerivedE> const& E,
    Eigen::DenseBase<TDerivedL>& L,
    Eigen::DenseBase<TDerivedU>& U)
{
    ClustersToAabbs<kDims, kElemNodes>(
        [&](Index e) {
            return X(Eigen::placeholders::all, E.col(e))
                .template topLeftCorner<kDims, kElemNodes>();
        },
        E.cols(),
        L,
        U);
}

template <auto kDims, auto kElemNodes, class TDerivedX, class TDerivedE, class TDerivedB>
inline void MeshToAabbs(
    Eigen::DenseBase<TDerivedX> const& X,
    Eigen::DenseBase<TDerivedE> const& E,
    Eigen::DenseBase<TDerivedB>& B)
{
    ClustersToAabbs<kDims, kElemNodes>(
        [&](Index e) {
            return X(Eigen::placeholders::all, E.col(e))
                .template topLeftCorner<kDims, kElemNodes>();
        },
        E.cols(),
        B);
}
} // namespace pbat::geometry
 
#endif // PBAT_GEOMETRY_AXISALIGNEDBOUNDINGBOX_H