MRObjectPointsHolder.h

Go to the documentation of this file.

#pragma once
 
#include "MRPch/MRBindingMacros.h"
#include "MRVisualObject.h"
#include "MRXfBasedCache.h"
#include "MRPointCloudPart.h"
 
namespace MR
{
 
enum class MRMESH_CLASS PointsVisualizePropertyType
{
    SelectedVertices,
    _count [[maybe_unused]],
};
template <> struct IsVisualizeMaskEnum<PointsVisualizePropertyType> : std::true_type {};
 
class MRMESH_CLASS ObjectPointsHolder : public VisualObject
{
public:
    MRMESH_API ObjectPointsHolder();
 
    ObjectPointsHolder( ObjectPointsHolder&& ) noexcept = default;
    ObjectPointsHolder& operator = ( ObjectPointsHolder&& ) noexcept = default;
 
    constexpr static const char* TypeName() noexcept { return "PointsHolder"; }
    virtual const char* typeName() const override { return TypeName(); }
 
    MRMESH_API virtual void applyScale( float scaleFactor ) override;
 
    MRMESH_API virtual bool hasVisualRepresentation() const override;
 
    [[nodiscard]] virtual bool hasModel() const override { return bool( points_ ); }
 
    const std::shared_ptr<const PointCloud>& pointCloud() const
    { return reinterpret_cast< const std::shared_ptr<const PointCloud>& >( points_ ); } // reinterpret_cast to avoid making a copy of shared_ptr
 
    [[nodiscard]] PointCloudPart pointCloudPart() const { return selectedPoints_.any() ? PointCloudPart{ *points_, &selectedPoints_ } : PointCloudPart{ *points_ }; }
 
    MRMESH_API virtual std::shared_ptr<Object> clone() const override;
    MRMESH_API virtual std::shared_ptr<Object> shallowClone() const override;
 
    MRMESH_API virtual void setDirtyFlags( uint32_t mask, bool invalidateCaches = true ) override;
 
    const VertBitSet& getSelectedPoints() const { return selectedPoints_; }
 
    void selectPoints( VertBitSet newSelection ) { updateSelectedPoints( newSelection ); }
 
    MRMESH_API virtual void updateSelectedPoints( VertBitSet& selection );
 
    MRMESH_API const VertBitSet& getSelectedPointsOrAll() const;
 
    const Color& getSelectedVerticesColor( ViewportId id = {} ) const
    {
        return selectedVerticesColor_.get( id );
    }
    MRMESH_API virtual void setSelectedVerticesColor( const Color& color, ViewportId id = {} );
 
    MRMESH_API const ViewportProperty<Color>& getSelectedVerticesColorsForAllViewports() const;
    MRMESH_API virtual void setSelectedVerticesColorsForAllViewports( ViewportProperty<Color> val );
 
    [[nodiscard]] MRMESH_API bool supportsVisualizeProperty( AnyVisualizeMaskEnum type ) const override;
 
    const VertColors& getVertsColorMap() const { return vertsColorMap_; }
 
    virtual void setVertsColorMap( VertColors vertsColorMap ) { vertsColorMap_ = std::move( vertsColorMap ); setDirtyFlags( DIRTY_VERTS_COLORMAP ); }
 
    virtual void updateVertsColorMap( VertColors& vertsColorMap ) { std::swap( vertsColorMap_, vertsColorMap ); setDirtyFlags( DIRTY_VERTS_COLORMAP ); }
 
    MRMESH_API virtual void copyColors( const ObjectPointsHolder & src, const VertMap & thisToSrc, const FaceMap& thisToSrcFaces = {} );
 
    MRMESH_API AllVisualizeProperties getAllVisualizeProperties() const override;
    MRMESH_API const ViewportMask& getVisualizePropertyMask( AnyVisualizeMaskEnum type ) const override;
 
    MRMESH_API virtual void setPointSize( float size );
    virtual float getPointSize() const { return pointSize_; }
 
    ObjectPointsHolder( ProtectedStruct, const ObjectPointsHolder& obj ) : ObjectPointsHolder( obj )
    {}
 
    MRMESH_API virtual Box3f getWorldBox( ViewportId = {} ) const override;
    MRMESH_API size_t numValidPoints() const;
    MRMESH_API size_t numSelectedPoints() const;
 
    [[nodiscard]] MRMESH_API virtual size_t heapBytes() const override;
 
    int getRenderDiscretization() const { return renderDiscretization_; }
 
    MRMESH_API size_t numRenderingValidPoints() const;
 
    static constexpr int MaxRenderingPointsDefault = 1'000'000;
    static constexpr int MaxRenderingPointsUnlimited = std::numeric_limits<int>::max();
 
    MRMESH_API int getMaxRenderingPoints() const { return maxRenderingPoints_; }
 
    MRMESH_API void setMaxRenderingPoints( int val );
 
    [[nodiscard]] const char * serializeFormat() const { return serializeFormat_; }
    [[deprecated]] MR_BIND_IGNORE const char * savePointsFormat() const { return serializeFormat(); }
 
    MRMESH_API void setSerializeFormat( const char * newFormat );
    [[deprecated]] MR_BIND_IGNORE void setSavePointsFormat( const char * newFormat ) { setSerializeFormat( newFormat ); }
 
    MRMESH_API void resetFrontColor() override;
    MRMESH_API void resetColors() override;
 
    using SelectionChangedSignal = Signal<void()>;
    SelectionChangedSignal pointsSelectionChangedSignal;
 
    Signal<void()> renderDiscretizationChangedSignal;
 
protected:
    VertBitSet selectedPoints_;
    mutable std::optional<size_t> numValidPoints_;
    mutable std::optional<size_t> numSelectedPoints_;
    ViewportProperty<Color> selectedVerticesColor_;
    ViewportMask showSelectedVertices_ = ViewportMask::all();
    VertColors vertsColorMap_;
 
    MRMESH_API virtual void swapSignals_( Object& other ) override;
 
    std::shared_ptr<PointCloud> points_;
    mutable ViewportProperty<XfBasedCache<Box3f>> worldBox_;
 
    float pointSize_{ 5.0f };
 
    ObjectPointsHolder( const ObjectPointsHolder& other ) = default;
 
    MRMESH_API virtual void swapBase_( Object& other ) override;
 
    MRMESH_API virtual Box3f computeBoundingBox_() const override;
 
    MRMESH_API virtual Expected<std::future<Expected<void>>> serializeModel_( const std::filesystem::path& path ) const override;
 
    MRMESH_API virtual Expected<void> deserializeModel_( const std::filesystem::path& path, ProgressCallback progressCb = {} ) override;
 
    MRMESH_API virtual void serializeFields_( Json::Value& root ) const override;
 
    MRMESH_API virtual void deserializeFields_( const Json::Value& root ) override;
 
    MRMESH_API virtual void setupRenderObject_() const override;
 
    MRMESH_API void setAllVisualizeProperties_( const AllVisualizeProperties& properties, std::size_t& pos ) override;
 
    int maxRenderingPoints_ = MaxRenderingPointsDefault;
 
private:
 
    void setDefaultColors_();
 
    void setDefaultSceneProperties_();
 
    // update renderDiscretization_ as numValidPoints_ / maxRenderingPoints_ (rounded up)
    void updateRenderDiscretization_();
 
    int renderDiscretization_ = 1; // auxiliary parameter to avoid recalculation in every frame
 
    const char * serializeFormat_ = nullptr; // means use defaultSerializePointsFormat()
};
 
[[nodiscard]] MRMESH_API const std::string & defaultSerializePointsFormat();
 
// serialization falls back to the PLY format if given format support is available
// NOTE: CTM format support is available in the MRIOExtras library; make sure to load it if you prefer CTM
MRMESH_API void setDefaultSerializePointsFormat( std::string newFormat );
 
} //namespace MR