Obb.hpp

#pragma once
 
#include <Core/RaCore.hpp>
#include <Eigen/Core>
#include <Eigen/Geometry>
 
namespace Ra {
namespace Core {
namespace Geometry {
class Obb
{
  public:
    using Transform = Eigen::Transform<Scalar, 3, Eigen::Affine>;
    using Aabb      = Eigen::AlignedBox<Scalar, 3>;
 
 
    inline Obb() : m_aabb(), m_transform( Transform::Identity() ) {}
 
    inline Obb( const Aabb& aabb, const Transform& tr ) : m_aabb( aabb ), m_transform( tr ) {}
 
    Obb( const Obb& other )            = default;
    Obb& operator=( const Obb& other ) = default;
 
    virtual inline ~Obb() {}
 
    inline Aabb toAabb() const {
        if ( m_aabb.isEmpty() ) { return m_aabb; }
        Aabb tmp;
        for ( int i = 0; i < 8; ++i ) {
            tmp.extend( worldCorner( i ) );
        }
        return tmp;
    }
 
    inline void addPoint( const Eigen::Matrix<Scalar, 3, 1>& p ) { m_aabb.extend( p ); }
 
    inline Eigen::Matrix<Scalar, 3, 1> corner( int i ) const {
        return m_aabb.corner( static_cast<Aabb::CornerType>( i ) );
    }
 
    inline Eigen::Matrix<Scalar, 3, 1> worldCorner( int i ) const {
        return m_transform * m_aabb.corner( static_cast<Aabb::CornerType>( i ) );
    }
 
    Transform& transform() { return m_transform; }
 
    const Transform& transform() const { return m_transform; }
 
  private:
    Aabb m_aabb;
    Transform m_transform;
};
} // namespace Geometry
} // namespace Core
} // namespace Ra