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_; }
 
    // prepare data for volume rendering
    // returns false if canceled or voxel data is empty
    MRVOXELS_API bool prepareDataForVolumeRendering( ProgressCallback cb = {} ) const;
 
    bool isVolumeRenderingEnabled() const { return volumeRendering_; }
    // this function should only be called from GUI thread because it changes rendering object,
    // it can take some time to prepare data, so you can prepare data with progress callback
    // by calling `prepareDataForVolumeRendering(cb)` function before calling this one
    MRVOXELS_API void enableVolumeRendering( bool on );
    // move volume rendering data to caller: basically used in RenderVolumeObject
    [[nodiscard]] std::unique_ptr<SimpleVolume> getVolumeRenderingData() const { return std::move( volumeRenderingData_ ); }
 
    // struct to control volume rendering texture
    struct VolumeRenderingParams
    {
        // volume texture smoothing
        FilterType volumeFilterType{ FilterType::Linear };
        // shading model
        enum class ShadingType
        {
            None,
            ValueGradient,
            AlphaGradient
        } shadingType{ ShadingType::None };
        // coloring type
        enum class LutType
        {
            GrayShades,
            Rainbow,
            OneColor
        } lutType{ LutType::Rainbow };
        // color that is used for OneColor mode
        Color oneColor{ Color::white() };
        // minimum colored value (voxels with lower values are transparent)
        float min{ 0.0f };
        // maximum colored value (voxels with higher values are transparent)
        float max{ 0.0f };
        // step to sample each ray with
        // if <= 0 then default sampling is used
        float samplingStep{ -1.0f };
        // type of alpha function on texture
        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; //means defaultSerializeVoxelsFormat()
 
    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 );
 
} //namespace MR