MRObjectPointsHolder.h

Go to the documentation of this file.

#pragma once
 
#include "MRPch/MRBindingMacros.h"
#include "MRBitSet.h"
#include "MRVisualObject.h"
#include "MRXfBasedCache.h"
#include "MRPointCloudPart.h"
#include "MRHeapBytes.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* StaticTypeName() noexcept { return "PointsHolder"; }
    virtual const char* typeName() const override { return StaticTypeName(); }
 
    MRMESH_API virtual void applyScale( float scaleFactor ) override;
 
    MRMESH_API virtual bool hasVisualRepresentation() const override;
 
    [[nodiscard]] virtual bool hasModel() const override { return bool( points_ ); }

    [[nodiscard]]       PointCloud* varPointCloudPtr() { return points_.get(); }

    [[nodiscard]] const PointCloud* pointCloudPtr() const { return points_.get(); }
 
    #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing" 
    #endif
    [[deprecated( "use pointCloudPtr() instead" )]]
    const std::shared_ptr<const PointCloud>& pointCloud() const
    { return reinterpret_cast< const std::shared_ptr<const PointCloud>& >( points_ ); } 
    #ifdef __GNUC__
    #pragma GCC diagnostic pop
    #endif

    [[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 );

    MRMESH_API void copyAllSolidColors( const ObjectPointsHolder& other );
 
    [[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;

    using ChangedSignal = Signal<void( uint32_t mask )>;
    ChangedSignal pointsChangedSignal;
    ChangedSignal normalsChangedSignal;
 
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_();

    void updateRenderDiscretization_();
 
    int renderDiscretization_ = 1; 
 
    const char * serializeFormat_ = nullptr; 
};

[[nodiscard]] MRMESH_API const std::string & defaultSerializePointsFormat();

MRMESH_API void setDefaultSerializePointsFormat( std::string newFormat );
 
}