IndexedGeometry.hpp

#pragma once
 
#include <Core/Containers/VectorArray.hpp>
#include <Core/Geometry/TriangleMesh.hpp>
#include <Core/Utils/ContainerIntrospectionInterface.hpp>
#include <Core/Utils/ObjectWithSemantic.hpp>
#include <Core/Utils/StdMapIterators.hpp>
 
#include <memory>
#include <unordered_map>
 
namespace Ra {
namespace Core {
namespace Geometry {
 
class RA_CORE_API GeometryIndexLayerBase : public Utils::ObservableVoid,
                                           public Utils::ObjectWithSemantic,
                                           public Utils::ContainerIntrospectionInterface
{
  public:
    inline explicit GeometryIndexLayerBase( const GeometryIndexLayerBase& other );
    inline GeometryIndexLayerBase& operator=( const GeometryIndexLayerBase& other );
    inline GeometryIndexLayerBase& operator=( GeometryIndexLayerBase&& other );
    virtual ~GeometryIndexLayerBase();
 
    virtual std::unique_ptr<GeometryIndexLayerBase> clone() = 0;
 
    virtual bool append( const GeometryIndexLayerBase& other ) = 0;
 
    virtual inline bool operator==( const GeometryIndexLayerBase& other ) const;
 
  protected:
    template <class... SemanticNames>
    inline GeometryIndexLayerBase( SemanticNames... names ) : ObjectWithSemantic( names... ) {}
};
 
template <typename T>
struct GeometryIndexLayer : public GeometryIndexLayerBase {
    using IndexType          = T;
    using IndexContainerType = VectorArray<IndexType>;
 
    inline IndexContainerType& collection();
    const IndexContainerType& collection() const;
 
    inline bool append( const GeometryIndexLayerBase& other ) final;
 
    inline bool operator==( const GeometryIndexLayerBase& other ) const final;
 
    inline size_t getSize() const override final;
 
    inline std::unique_ptr<GeometryIndexLayerBase> clone() override final;
 
    inline size_t getNumberOfComponents() const override final;
 
    inline size_t getBufferSize() const override final;
 
    inline int getStride() const override final;
 
    inline const void* dataPtr() const override final;
 
  protected:
    template <class... SemanticNames>
    inline GeometryIndexLayer( SemanticNames... names ) : GeometryIndexLayerBase( names... ) {}
 
  private:
    IndexContainerType m_collection;
};
 
class RA_CORE_API MultiIndexedGeometry : public AttribArrayGeometry, public Utils::ObservableVoid
{
  public:
    using LayerSemanticCollection = Utils::ObjectWithSemantic::SemanticNameCollection;
    using LayerSemantic           = Utils::ObjectWithSemantic::SemanticName;
    using LayerKeyType            = std::pair<LayerSemanticCollection, std::string>;
 
    using PointAttribHandle  = AttribArrayGeometry::PointAttribHandle;
    using NormalAttribHandle = AttribArrayGeometry::NormalAttribHandle;
    using FloatAttribHandle  = AttribArrayGeometry::FloatAttribHandle;
    using Vec2AttribHandle   = AttribArrayGeometry::Vec2AttribHandle;
    using Vec3AttribHandle   = AttribArrayGeometry::Vec3AttribHandle;
    using Vec4AttribHandle   = AttribArrayGeometry::Vec4AttribHandle;
 
    inline MultiIndexedGeometry() = default;
    explicit MultiIndexedGeometry( const MultiIndexedGeometry& other );
    explicit MultiIndexedGeometry( MultiIndexedGeometry&& other );
    explicit MultiIndexedGeometry( const AttribArrayGeometry& other );
    explicit MultiIndexedGeometry( AttribArrayGeometry&& other );
    MultiIndexedGeometry& operator=( const MultiIndexedGeometry& other );
    MultiIndexedGeometry& operator=( MultiIndexedGeometry&& other );
 
    virtual inline ~MultiIndexedGeometry();
    void clear() override;
 
    void copy( const MultiIndexedGeometry& other );
 
    void checkConsistency() const;
 
    bool append( const MultiIndexedGeometry& other );
 
 
    inline bool containsLayer( const LayerKeyType& layerKey ) const;
 
    inline bool containsLayer( const LayerSemanticCollection& semantics,
                               const std::string& layerName ) const;
 
    bool containsLayer( const LayerSemanticCollection& semantics ) const;
 
    bool containsLayer( const LayerSemantic& semanticName ) const;
 
 
    inline size_t countLayers( const LayerKeyType& layerKey ) const;
 
    inline size_t countLayers( const LayerSemanticCollection& semantics,
                               const std::string& layerName ) const;
 
    size_t countLayers( const LayerSemanticCollection& semantics ) const;
 
    size_t countLayers( const LayerSemantic& semanticName ) const;
 
 
    inline const GeometryIndexLayerBase& getLayer( const LayerKeyType& layerKey ) const;
 
    inline const GeometryIndexLayerBase& getLayer( const LayerSemanticCollection& semantics,
                                                   const std::string& layerName ) const;
    std::pair<LayerKeyType, const GeometryIndexLayerBase&>
    getFirstLayerOccurrence( const LayerSemanticCollection& semantics ) const;
 
    std::pair<LayerKeyType, const GeometryIndexLayerBase&>
    getFirstLayerOccurrence( const LayerSemantic& semanticName ) const;
 
 
    GeometryIndexLayerBase& getLayerWithLock( const LayerKeyType& layerKey );
 
    inline GeometryIndexLayerBase& getLayerWithLock( const LayerSemanticCollection& semantics,
                                                     const std::string& layerName );
 
    std::pair<LayerKeyType, GeometryIndexLayerBase&>
    getFirstLayerOccurrenceWithLock( const LayerSemanticCollection& semantics );
 
    std::pair<LayerKeyType, GeometryIndexLayerBase&>
    getFirstLayerOccurrenceWithLock( const LayerSemantic& semanticName );
 
 
    void unlockLayer( const LayerKeyType& layerKey );
 
    inline void unlockLayer( const LayerSemanticCollection& semantics,
                             const std::string& layerName );
 
    // The following methods are only mean to be used by PredifinedIndexGeometry and should not be
    // part of the final API
  protected:
    void unlockFirstLayerOccurrence( const LayerSemanticCollection& semantics );
 
    void unlockFirstLayerOccurrence( const LayerSemantic& semanticName );
 
  public:
    std::pair<bool, GeometryIndexLayerBase&>
    addLayer( std::unique_ptr<GeometryIndexLayerBase>&& layer,
              const bool withLock          = false,
              const std::string& layerName = "" );
 
    [[nodiscard]] inline auto layerKeys() const;
 
  private:
    void deepCopy( const MultiIndexedGeometry& other );
 
    void deepClear();
 
    using EntryType = std::pair<bool, std::unique_ptr<GeometryIndexLayerBase>>;
 
    struct RA_CORE_API KeyHash {
        std::size_t operator()( const LayerKeyType& k ) const;
    };
 
    std::unordered_map<LayerKeyType, EntryType, KeyHash> m_indices;
};
 
 
struct RA_CORE_API PointCloudIndexLayer : public GeometryIndexLayer<Vector1ui> {
    inline PointCloudIndexLayer();
 
    inline explicit PointCloudIndexLayer( size_t n );
 
    void linearIndices( const AttribArrayGeometry& attr );
 
    static constexpr const char* staticSemanticName = "PointCloud";
 
  protected:
    template <class... SemanticNames>
    inline PointCloudIndexLayer( SemanticNames... names );
};
 
struct RA_CORE_API TriangleIndexLayer : public GeometryIndexLayer<Vector3ui> {
    inline TriangleIndexLayer();
    static constexpr const char* staticSemanticName = "TriangleMesh";
 
  protected:
    template <class... SemanticNames>
    inline explicit TriangleIndexLayer( SemanticNames... names );
};
 
struct RA_CORE_API QuadIndexLayer : public GeometryIndexLayer<Vector4ui> {
    inline QuadIndexLayer();
    static constexpr const char* staticSemanticName = "QuadMesh";
 
  protected:
    template <class... SemanticNames>
    inline explicit QuadIndexLayer( SemanticNames... names );
};
 
struct RA_CORE_API PolyIndexLayer : public GeometryIndexLayer<VectorNui> {
    inline PolyIndexLayer();
    static constexpr const char* staticSemanticName = "PolyMesh";
 
  protected:
    template <class... SemanticNames>
    inline explicit PolyIndexLayer( SemanticNames... names );
};
 
struct RA_CORE_API LineIndexLayer : public GeometryIndexLayer<Vector2ui> {
    inline LineIndexLayer();
    static constexpr const char* staticSemanticName = "LineMesh";
 
  protected:
    template <class... SemanticNames>
    inline explicit LineIndexLayer( SemanticNames... names );
};
 
 
namespace IndexLayerType {
template <class IndexT>
struct getType {};
 
template <>
struct getType<Vector2ui> {
    using Type = Ra::Core::Geometry::LineIndexLayer;
};
 
template <>
struct getType<Vector3ui> {
    using Type = Ra::Core::Geometry::TriangleIndexLayer;
};
 
template <>
struct getType<Vector4ui> {
    using Type = Ra::Core::Geometry::QuadIndexLayer;
};
 
template <>
struct getType<VectorNui> {
    using Type = Ra::Core::Geometry::PolyIndexLayer;
};
 
template <>
struct getType<Vector1ui> {
    using Type = Ra::Core::Geometry::PointCloudIndexLayer;
};
 
} // namespace IndexLayerType
 
template <typename T>
class IndexedGeometry : public MultiIndexedGeometry
{
  public:
    using IndexType          = T;
    using IndexContainerType = VectorArray<IndexType>;
 
  private:
    using DefaultLayerType = typename IndexLayerType::getType<IndexType>::Type;
 
  public:
    inline IndexedGeometry();
 
    inline const IndexContainerType& getIndices() const;
    inline IndexContainerType& getIndicesWithLock();
 
    inline void indicesUnlock();
    inline void setIndices( IndexContainerType&& indices );
    inline void setIndices( const IndexContainerType& indices );
    inline const LayerKeyType& getLayerKey() const;
 
  private:
    LayerKeyType m_mainIndexLayerKey;
};
 
class RA_CORE_API IndexedPointCloud : public IndexedGeometry<Vector1ui>
{};
 
class RA_CORE_API TriangleMesh : public IndexedGeometry<Vector3ui>
{};
 
class RA_CORE_API QuadMesh : public IndexedGeometry<Vector4ui>
{};
 
class RA_CORE_API PolyMesh : public IndexedGeometry<VectorNui>
{};
 
class RA_CORE_API LineMesh : public IndexedGeometry<Vector2ui>
{};
 
//  GeometryIndexLayerBase
inline GeometryIndexLayerBase::GeometryIndexLayerBase( const GeometryIndexLayerBase& other ) :
    ObjectWithSemantic( other.semantics() ) {}
 
inline GeometryIndexLayerBase&
GeometryIndexLayerBase::operator=( const GeometryIndexLayerBase& other ) {
    CORE_UNUSED( other );
    CORE_ASSERT( semantics() == other.semantics(),
                 "Try to assign object with different semantics" );
    return *this;
}
 
inline GeometryIndexLayerBase& GeometryIndexLayerBase::operator=( GeometryIndexLayerBase&& other ) {
    CORE_UNUSED( other );
    CORE_ASSERT( semantics() == other.semantics(),
                 "Try to assign GeometryIndexLayer of different type" );
    return *this;
}
 
inline GeometryIndexLayerBase::~GeometryIndexLayerBase() {}
 
inline bool GeometryIndexLayerBase::operator==( const GeometryIndexLayerBase& ) const {
    return false;
}
 
// GeometryIndexLayer
 
template <typename T>
inline typename GeometryIndexLayer<T>::IndexContainerType& GeometryIndexLayer<T>::collection() {
    return m_collection;
}
 
template <typename T>
const typename GeometryIndexLayer<T>::IndexContainerType&
GeometryIndexLayer<T>::collection() const {
    return m_collection;
}
 
template <typename T>
inline bool GeometryIndexLayer<T>::append( const GeometryIndexLayerBase& other ) {
    if ( shareSemantic( other ) ) {
        const auto& othercasted = static_cast<const GeometryIndexLayer<T>&>( other );
        m_collection.insert(
            m_collection.end(), othercasted.collection().begin(), othercasted.collection().end() );
        return true;
    }
    return false;
}
 
template <typename T>
inline bool GeometryIndexLayer<T>::operator==( const GeometryIndexLayerBase& other ) const {
    if ( shareSemantic( other ) ) {
        const auto& othercasted = static_cast<const GeometryIndexLayer<T>&>( other );
        return othercasted.collection() == m_collection;
    }
    return false;
}
 
template <typename T>
inline size_t GeometryIndexLayer<T>::getSize() const {
    return m_collection.size();
}
 
template <typename T>
inline size_t GeometryIndexLayer<T>::getNumberOfComponents() const {
    return IndexType::RowsAtCompileTime;
}
 
template <typename T>
inline size_t GeometryIndexLayer<T>::getBufferSize() const {
    return m_collection.size() * sizeof( IndexType );
}
 
template <typename T>
inline int GeometryIndexLayer<T>::getStride() const {
    return sizeof( IndexType );
}
 
template <typename T>
inline const void* GeometryIndexLayer<T>::dataPtr() const {
    return m_collection.data();
}
 
template <typename T>
inline std::unique_ptr<GeometryIndexLayerBase> GeometryIndexLayer<T>::clone() {
    auto copy          = std::make_unique<GeometryIndexLayer<T>>( *this );
    copy->m_collection = m_collection;
    return copy;
}
 
// MultiIndexedGeometry
inline MultiIndexedGeometry::~MultiIndexedGeometry() {
    detachAll();
    clear();
}
 
inline bool
MultiIndexedGeometry::containsLayer( const MultiIndexedGeometry::LayerKeyType& layerKey ) const {
    return m_indices.find( layerKey ) != m_indices.end();
}
 
inline bool
MultiIndexedGeometry::containsLayer( const MultiIndexedGeometry::LayerSemanticCollection& semantics,
                                     const std::string& layerName ) const {
    return containsLayer( { semantics, layerName } );
}
 
inline size_t
MultiIndexedGeometry::countLayers( const MultiIndexedGeometry::LayerKeyType& layerKey ) const {
    return m_indices.count( layerKey );
}
 
inline size_t
MultiIndexedGeometry::countLayers( const MultiIndexedGeometry::LayerSemanticCollection& semantics,
                                   const std::string& layerName ) const {
    return countLayers( { semantics, layerName } );
}
 
inline const GeometryIndexLayerBase&
MultiIndexedGeometry::getLayer( const MultiIndexedGeometry::LayerKeyType& layerKey ) const {
    return *( m_indices.at( layerKey ).second.get() );
}
 
inline GeometryIndexLayerBase& MultiIndexedGeometry::getLayerWithLock(
    const MultiIndexedGeometry::LayerSemanticCollection& semantics,
    const std::string& layerName ) {
    return getLayerWithLock( { semantics, layerName } );
}
 
inline void
MultiIndexedGeometry::unlockLayer( const MultiIndexedGeometry::LayerSemanticCollection& semantics,
                                   const std::string& layerName ) {
    unlockLayer( { semantics, layerName } );
}
 
[[nodiscard]] inline auto MultiIndexedGeometry::layerKeys() const {
    return Utils::map_keys( m_indices );
}
 
// PointCloudIndexLayer
inline PointCloudIndexLayer::PointCloudIndexLayer() :
    GeometryIndexLayer( PointCloudIndexLayer::staticSemanticName ) {}
inline PointCloudIndexLayer::PointCloudIndexLayer( size_t n ) :
    GeometryIndexLayer( PointCloudIndexLayer::staticSemanticName ) {
    collection().resize( n );
    collection().getMap() = IndexContainerType::Matrix::LinSpaced( n, 0, n - 1 );
}
template <class... SemanticNames>
inline PointCloudIndexLayer::PointCloudIndexLayer( SemanticNames... names ) :
    GeometryIndexLayer( PointCloudIndexLayer::staticSemanticName, names... ) {}
// TriangleIndexLayer
inline TriangleIndexLayer::TriangleIndexLayer() :
    GeometryIndexLayer( TriangleIndexLayer::staticSemanticName ) {}
template <class... SemanticNames>
inline TriangleIndexLayer::TriangleIndexLayer( SemanticNames... names ) :
    GeometryIndexLayer( TriangleIndexLayer::staticSemanticName, names... ) {}
// QuadIndexLayer
inline QuadIndexLayer::QuadIndexLayer() :
    GeometryIndexLayer( QuadIndexLayer::staticSemanticName ) {}
template <class... SemanticNames>
inline QuadIndexLayer::QuadIndexLayer( SemanticNames... names ) :
    GeometryIndexLayer( QuadIndexLayer::staticSemanticName, names... ) {}
// PolyIndexLayer
inline PolyIndexLayer::PolyIndexLayer() :
    GeometryIndexLayer( PolyIndexLayer::staticSemanticName ) {}
template <class... SemanticNames>
inline PolyIndexLayer::PolyIndexLayer( SemanticNames... names ) :
    GeometryIndexLayer( PolyIndexLayer::staticSemanticName, names... ) {}
// LineIndexLayer
inline LineIndexLayer::LineIndexLayer() :
    GeometryIndexLayer( LineIndexLayer::staticSemanticName ) {}
template <class... SemanticNames>
inline LineIndexLayer::LineIndexLayer( SemanticNames... names ) :
    GeometryIndexLayer( LineIndexLayer::staticSemanticName, names... ) {}
// IndexedGeometry
template <typename T>
inline IndexedGeometry<T>::IndexedGeometry() {
    auto layer          = std::make_unique<DefaultLayerType>();
    m_mainIndexLayerKey = { layer->semantics(), "" };
    addLayer( std::move( layer ) );
}
 
template <typename T>
 
inline const typename IndexedGeometry<T>::IndexContainerType&
IndexedGeometry<T>::getIndices() const {
    const auto& abstractLayer = getLayer( m_mainIndexLayerKey );
    return static_cast<const IndexedGeometry<T>::DefaultLayerType&>( abstractLayer ).collection();
}
template <typename T>
inline typename IndexedGeometry<T>::IndexContainerType& IndexedGeometry<T>::getIndicesWithLock() {
    auto& abstractLayer = getLayerWithLock( m_mainIndexLayerKey );
    return static_cast<IndexedGeometry<T>::DefaultLayerType&>( abstractLayer ).collection();
}
 
template <typename T>
inline void IndexedGeometry<T>::indicesUnlock() {
    unlockLayer( m_mainIndexLayerKey );
}
 
template <typename T>
inline void IndexedGeometry<T>::setIndices( IndexContainerType&& indices ) {
    auto& abstractLayer = getLayerWithLock( m_mainIndexLayerKey );
    static_cast<IndexedGeometry<T>::DefaultLayerType&>( abstractLayer ).collection() =
        std::move( indices );
    notify();
}
 
template <typename T>
inline void IndexedGeometry<T>::setIndices( const IndexContainerType& indices ) {
    auto& abstractLayer = getLayerWithLock( m_mainIndexLayerKey );
    static_cast<IndexedGeometry<T>::DefaultLayerType&>( abstractLayer ).collection() = indices;
    notify();
}
 
template <typename T>
inline const typename IndexedGeometry<T>::LayerKeyType& IndexedGeometry<T>::getLayerKey() const {
    return m_mainIndexLayerKey;
}
 
} // namespace Geometry
} // namespace Core
} // namespace Ra