Volume.hpp

#pragma once
 
#include <Core/Geometry/AbstractGeometry.hpp>
#include <Core/RaCore.hpp>
#include <Core/Types.hpp>
 
#define RA_REQUIRE_OPTIONAL
#include <Core/Utils/StdOptional.hpp> // trigger an error if optional is not found
#undef RA_REQUIRE_OPTIONAL
 
#include <algorithm> // find_if
 
namespace Ra {
namespace Core {
namespace Geometry {
 
class RA_CORE_API AbstractVolume : public AbstractGeometry
{
 
  public:
    enum VolumeStorageType {
        UNKNOWN         = 1 << 0,
        PARAMETRIC      = 1 << 1, 
        DISCRETE_DENSE  = 1 << 2, 
        DISCRETE_SPARSE = 1 << 3  
    };
 
    using ValueType = Scalar;
 
  protected:
    AbstractVolume( const VolumeStorageType& type );
 
  public:
    AbstractVolume( const AbstractVolume& data )       = default;
    AbstractVolume& operator=( const AbstractVolume& ) = default;
    ~AbstractVolume()                                  = default;
 
    inline VolumeStorageType getType() const { return m_type; }
 
  protected:
    inline void setType( const VolumeStorageType& type ) { m_type = type; }
 
  public:
    virtual Utils::optional<ValueType> getValue( Eigen::Ref<const Vector3> p ) const = 0;
 
    bool isParametric() const;
    bool isDiscrete() const;
    bool isDense() const;
    bool isSparse() const;
 
    void displayInfo() const;
 
  protected:
    VolumeStorageType m_type;
};
class RA_CORE_API AbstractDiscreteVolume : public AbstractVolume
{
 
  public:
    using ValueType = AbstractVolume::ValueType;
    using IndexType = Vector3i;
 
  protected:
    inline AbstractDiscreteVolume( const VolumeStorageType& type ) :
        AbstractVolume( type ), m_size( IndexType::Zero() ), m_binSize { 1_ra, 1_ra, 1_ra } {}
 
  public:
    AbstractDiscreteVolume( const AbstractDiscreteVolume& data )       = default;
    AbstractDiscreteVolume& operator=( const AbstractDiscreteVolume& ) = default;
    ~AbstractDiscreteVolume() override                                 = default;
 
    void clear() override;
 
    Aabb computeAabb() const override;
 
    const Vector3i& size() const { return m_size; }
    void setSize( Eigen::Ref<const Vector3i> size ) {
        m_size = size;
        updateStorage();
        invalidateAabb();
    }
    const Vector3& binSize() const { return m_binSize; }
 
    void setBinSize( Eigen::Ref<const Vector3> binSize ) {
        CORE_ASSERT( binSize != Vector3::Zero(), "Volume bin size can't be zero." );
        m_binSize = binSize;
        invalidateAabb();
    }
 
    inline Utils::optional<ValueType> getBinValue( Eigen::Ref<const IndexType> p ) const {
        if ( auto res = linearIndex( p ) ) return getBinValue( *res );
        return {};
    }
 
    inline Utils::optional<ValueType> getValue( Eigen::Ref<const Vector3> p ) const override final {
        return getBinValue( ( p.cwiseQuotient( m_binSize ) ).cast<typename IndexType::Scalar>() );
    }
 
    inline bool addToBin( const ValueType& value, Eigen::Ref<const IndexType> p ) {
        if ( auto res = linearIndex( p ) ) {
            addToBin( value, *res );
            invalidateAabb();
            return true;
        }
        return false;
    }
 
  protected:
    inline Utils::optional<typename IndexType::Scalar>
    linearIndex( Eigen::Ref<const IndexType> p ) const {
        using Integer = typename IndexType::Scalar;
        if ( ( p.array() >= m_size.array() ).any() ) return {};
        return p.dot( IndexType( Integer( 1 ), m_size( 0 ), m_size( 0 ) * m_size( 1 ) ) );
    }
    virtual Utils::optional<ValueType> getBinValue( typename IndexType::Scalar idx ) const = 0;
    virtual void addToBin( const ValueType& value, typename IndexType::Scalar idx ) = 0;
 
    virtual void updateStorage() = 0;
 
  private:
    IndexType m_size;  
    Vector3 m_binSize; 
};
 
class RA_CORE_API VolumeGrid : public AbstractDiscreteVolume
{
  public:
    using ValueType = AbstractDiscreteVolume::ValueType;
    using IndexType = AbstractDiscreteVolume::IndexType;
    // Stores the 3 partial derivatives of the density if the 3 first components and the density as
    // fourth component.
    using GradientType = Eigen::Matrix<ValueType, 4, 1>;
 
    using Container         = std::vector<ValueType>;
    using GradientContainer = std::vector<GradientType>;
 
  public:
    inline VolumeGrid( const ValueType& defaultValue = ValueType( 0. ) ) :
        AbstractDiscreteVolume( DISCRETE_DENSE ), m_defaultValue( defaultValue ) {}
    VolumeGrid( const VolumeGrid& data )       = default;
    VolumeGrid& operator=( const VolumeGrid& ) = default;
    ~VolumeGrid() override                     = default;
 
    using AbstractDiscreteVolume::addToBin;
    using AbstractDiscreteVolume::getBinValue;
 
    inline const Container& data() const { return m_data; }
    inline Container& data() { return m_data; }
 
    inline void addToAllBins( const ValueType& value ) {
        for ( auto& v : m_data ) {
            v += value;
        }
    }
 
    bool hasGradients() const { return m_data.size() == m_gradient.size(); }
 
    void computeGradients();
 
    inline const GradientContainer& gradient() const { return m_gradient; }
    inline GradientContainer& gradient() { return m_gradient; }
 
  protected:
    inline Utils::optional<ValueType> getBinValue( typename IndexType::Scalar idx ) const override {
        return m_data[size_t( idx )];
    }
 
    inline void addToBin( const ValueType& value, typename IndexType::Scalar idx ) override {
        m_data[size_t( idx )] += value;
    }
 
    inline void updateStorage() override {
        m_data.resize( size_t( size().prod() ), m_defaultValue );
    }
 
  private:
    ValueType sample( const IndexType& i );
 
    ValueType m_defaultValue;
    Container m_data;
    GradientContainer m_gradient;
}; // class VolumeGrid
 
class RA_CORE_API VolumeSparse : public AbstractDiscreteVolume
{
  public:
    using ValueType = AbstractDiscreteVolume::ValueType;
    using IndexType = AbstractDiscreteVolume::IndexType;
    struct SampleType {
        int index;
        ValueType value;
 
        inline SampleType( int idx, const ValueType& v ) : index( idx ), value( v ) {}
    };
    using Container = std::vector<SampleType>;
 
  public:
    inline VolumeSparse() : AbstractDiscreteVolume( DISCRETE_SPARSE ) {}
    VolumeSparse( const VolumeSparse& data )       = default;
    VolumeSparse& operator=( const VolumeSparse& ) = default;
    ~VolumeSparse() override                       = default;
 
    using AbstractDiscreteVolume::addToBin;
    using AbstractDiscreteVolume::getBinValue;
 
  protected:
    inline Utils::optional<ValueType> getBinValue( typename IndexType::Scalar idx ) const override {
        auto res = findBin( idx );
        if ( res != std::end( m_data ) ) return res->value;
        return {};
    }
 
    inline void addToBin( const ValueType& value, typename IndexType::Scalar idx ) override {
        auto res = findBin( idx );
        if ( res != std::end( m_data ) )
            res->value += value;
        else
            m_data.emplace_back( idx, value );
    }
 
    inline void updateStorage() override { m_data.clear(); }
 
  private:
    inline Container::iterator findBin( typename IndexType::Scalar idx ) {
        return std::find_if( std::begin( m_data ),
                             std::end( m_data ),
                             [&idx]( const SampleType& s ) { return s.index == idx; } );
    }
    inline Container::const_iterator findBin( typename IndexType::Scalar idx ) const {
        return std::find_if( std::begin( m_data ),
                             std::end( m_data ),
                             [&idx]( const SampleType& s ) { return s.index == idx; } );
    }
 
  private:
    Container m_data;
 
}; // class VolumeSparse
 
} // namespace Geometry
} // namespace Core
} // namespace Ra