MRObjectVoxels.h

Go to the documentation of this file.

#pragma once
#include "MRVoxelsFwd.h"
 
#include "MRMesh/MRObjectMeshHolder.h"
#include "MRMesh/MRProgressCallback.h"
#include "MRMesh/MRHistogram.h"
#include "MRMesh/MRVolumeIndexer.h"
#include "MRVoxelsVolume.h"
#include "MRMarchingCubes.h"
 
namespace MR
{
 

class MRVOXELS_CLASS ObjectVoxels : public ObjectMeshHolder
{
public:
    MRVOXELS_API ObjectVoxels();
    ObjectVoxels& operator = ( ObjectVoxels&& ) noexcept = default;
    ObjectVoxels( ObjectVoxels&& ) noexcept = default;
    virtual ~ObjectVoxels() = default;
 
    constexpr static const char* StaticTypeName() noexcept { return "ObjectVoxels"; }
    virtual const char* typeName() const override { return StaticTypeName(); }
 
    constexpr static const char* StaticClassName() noexcept { return "Voxel Volume"; }
    virtual std::string className() const override { return StaticClassName(); }
 
    constexpr static const char* StaticClassNameInPlural() noexcept { return "Voxel Volumes"; }
    virtual std::string classNameInPlural() const override { return StaticClassNameInPlural(); }
 
    MRVOXELS_API virtual void applyScale( float scaleFactor ) override;

    const std::shared_ptr<Mesh>& surface() const { return data_.mesh; }

    const VdbVolume& vdbVolume() const { return vdbVolume_; };
    VdbVolume& varVdbVolume() { return vdbVolume_; }

    const FloatGrid& grid() const { return vdbVolume_.data; }
 
    [[nodiscard]] virtual bool hasModel() const override { return bool( vdbVolume_.data ); }

    const Vector3i& dimensions() const
    { return vdbVolume_.dims; }

    float getIsoValue() const
    { return isoValue_; }

    const Histogram& histogram() const
    { return histogram_; }
 
    const Vector3f& voxelSize() const
    { return vdbVolume_.voxelSize; }
 
    MRVOXELS_API virtual std::vector<std::string> getInfoLines() const override;

    MRVOXELS_API void construct( const SimpleVolume& simpleVolume, const std::optional<Vector2f> & minmax = {}, ProgressCallback cb = {}, bool normalPlusGrad = false );

    MRVOXELS_API void construct( const SimpleVolumeMinMax& simpleVolumeMinMax, ProgressCallback cb = {}, bool normalPlusGrad = false );

    MRVOXELS_API void construct( const FloatGrid& grid, const Vector3f& voxelSize, const std::optional<Vector2f> & minmax = {} );

    MRVOXELS_API void construct( const VdbVolume& vdbVolume );

    MRVOXELS_API void updateHistogramAndSurface( ProgressCallback cb = {} );

    MRVOXELS_API virtual Expected<bool> setIsoValue( float iso, ProgressCallback cb = {}, bool updateSurface = true );

    MRVOXELS_API std::shared_ptr<Mesh> updateIsoSurface( std::shared_ptr<Mesh> mesh );
    MRVOXELS_API VdbVolume updateVdbVolume( VdbVolume vdbVolume );
    MRVOXELS_API Histogram updateHistogram( Histogram histogram );

    MRVOXELS_API Expected<std::shared_ptr<Mesh>> recalculateIsoSurface( float iso, ProgressCallback cb = {} ) const;
    MRVOXELS_API Expected<std::shared_ptr<Mesh>> recalculateIsoSurface( const VdbVolume& volume, float iso, ProgressCallback cb = {} ) const;
    MRVOXELS_API Histogram recalculateHistogram( std::optional<Vector2f> minmax, ProgressCallback cb = {} ) const;
    bool getDualMarchingCubes() const { return dualMarchingCubes_; }
    MRVOXELS_API virtual void setDualMarchingCubes( bool on, bool updateSurface = true, ProgressCallback cb = {} );
    virtual void setVoxelPointPositioner( VoxelPointPositioner positioner ) { positioner_ = positioner; }
 

    MRVOXELS_API virtual void setActiveBounds( const Box3i& activeBox, ProgressCallback cb = {}, bool updateSurface = true );
    MRVOXELS_API const Box3i& getActiveBounds() const;
    MRVOXELS_API virtual void invalidateActiveBoundsCaches();
 
    const VoxelBitSet& getSelectedVoxels() const { return selectedVoxels_; }
    void selectVoxels( const VoxelBitSet& selectedVoxels ) { selectedVoxels_ = selectedVoxels; }

    const VoxelBitSet& getVolumeRenderActiveVoxels() const { return volumeRenderActiveVoxels_; }
    MRVOXELS_API void setVolumeRenderActiveVoxels( const VoxelBitSet& activeVoxels );

    MRVOXELS_API VoxelId getVoxelIdByCoordinate( const Vector3i& coord ) const;
    MRVOXELS_API VoxelId getVoxelIdByPoint( const Vector3f& point ) const;
    MRVOXELS_API Vector3i getCoordinateByVoxelId( VoxelId id ) const;

    const VolumeIndexer& getVolumeIndexer() const { return indexer_; }

    MRVOXELS_API bool prepareDataForVolumeRendering( ProgressCallback cb = {} ) const;
 
    bool isVolumeRenderingEnabled() const { return volumeRendering_; }
    MRVOXELS_API void enableVolumeRendering( bool on );
    [[nodiscard]] std::unique_ptr<SimpleVolume> getVolumeRenderingData() const { return std::move( volumeRenderingData_ ); }

    struct VolumeRenderingParams
    {
        FilterType volumeFilterType{ FilterType::Linear };
        enum class ShadingType
        {
            None,
            ValueGradient,
            AlphaGradient
        } shadingType{ ShadingType::None };

        enum class LutType
        {
            GrayShades,
            Rainbow,
            OneColor
        } lutType{ LutType::Rainbow };

        Color oneColor{ Color::white() };
        float min{ 0.0f };
        float max{ 0.0f };
        float samplingStep{ -1.0f };
        enum class AlphaType
        {
            Constant,
            LinearIncreasing,
            LinearDecreasing
        } alphaType{ AlphaType::Constant };
        uint8_t alphaLimit{ 10 };
        bool operator==( const VolumeRenderingParams& )const = default;
    };
    const VolumeRenderingParams& getVolumeRenderingParams() const { return volumeRenderingParams_; }
    MRVOXELS_API void setVolumeRenderingParams( const VolumeRenderingParams& params );
 
    MRVOXELS_API virtual bool hasVisualRepresentation() const override;

    MRVOXELS_API void setMaxSurfaceVertices( int maxVerts );
    int getMaxSurfaceVertices() const { return maxSurfaceVertices_; }
 
    MRVOXELS_API virtual std::shared_ptr<Object> clone() const override;
    MRVOXELS_API virtual std::shared_ptr<Object> shallowClone() const override;
 
    MRVOXELS_API virtual void setDirtyFlags( uint32_t mask, bool invalidateCaches = true ) override;

    [[nodiscard]] MRVOXELS_API size_t activeVoxels() const;

    ObjectVoxels( ProtectedStruct, const ObjectVoxels& obj ) : ObjectVoxels( obj ) {}

    [[nodiscard]] MRVOXELS_API virtual size_t heapBytes() const override;

    [[nodiscard]] const char * serializeFormat() const { return serializeFormat_; }

    MRVOXELS_API void setSerializeFormat( const char * newFormat );

    MRVOXELS_API void resetFrontColor() override;

    using IsoSurfaceChangedSignal = Signal<void()>;
    IsoSurfaceChangedSignal isoSurfaceChangedSignal;

    using VoxelsChangedSignal = Signal<void()>;
    VoxelsChangedSignal voxelsChangedSignal;
 
private:
    VolumeRenderingParams volumeRenderingParams_;
    mutable UniquePtr<SimpleVolume> volumeRenderingData_;
 
    int maxSurfaceVertices_{ 5'000'000 };
    VdbVolume vdbVolume_;
    float isoValue_{0.0f};
    bool dualMarchingCubes_{true};
    VoxelPointPositioner positioner_ = {};
    Histogram histogram_;
    mutable std::optional<Box3i> activeBounds_;
    mutable std::optional<size_t> activeVoxels_;
 
    const char * serializeFormat_ = nullptr; 

    VolumeIndexer indexer_ = VolumeIndexer( vdbVolume_.dims );
    Vector3f reverseVoxelSize_;
 
    void updateHistogram_( float min, float max, ProgressCallback cb = {} );
 

    void setDefaultColors_();

    void setDefaultSceneProperties_();
 
protected:
    VoxelBitSet selectedVoxels_;
    VoxelBitSet volumeRenderActiveVoxels_;
 
    ObjectVoxels( const ObjectVoxels& other ) = default;
    bool volumeRendering_{ false };

    MRVOXELS_API virtual void swapBase_( Object& other ) override;
    MRVOXELS_API virtual void swapSignals_( Object& other ) override;
 
    MRVOXELS_API virtual void serializeFields_( Json::Value& root ) const override;
 
    MRVOXELS_API void deserializeFields_( const Json::Value& root ) override;
 
    MRVOXELS_API Expected<void> deserializeModel_( const std::filesystem::path& path, ProgressCallback progressCb = {} ) override;
 
    MRVOXELS_API virtual Expected<std::future<Expected<void>>> serializeModel_( const std::filesystem::path& path ) const override;
};

[[nodiscard]] MRVOXELS_API const std::string & defaultSerializeVoxelsFormat();

MRVOXELS_API void setDefaultSerializeVoxelsFormat( std::string newFormat );
 
}