MRVoxels/MRVDBConversions.h

Go to the documentation of this file.

#pragma once
 
#include "MRVoxelsFwd.h"
 
#include "MRMesh/MRMeshPart.h"
#include "MRMesh/MRProgressCallback.h"
#include "MRMesh/MRAffineXf3.h"
#include "MRMesh/MRExpected.h"
#include "MRMesh/MRBox.h"
#include <climits>
#include <string>
#include <optional>
 
namespace MR
{
 
// closed surface is required
// surfaceOffset - number voxels around surface to calculate distance in (should be positive)
// returns null if was canceled by progress callback
MRVOXELS_API FloatGrid meshToLevelSet( const MeshPart& mp, const AffineXf3f& xf,
                                     const Vector3f& voxelSize, float surfaceOffset = 3,
                                     ProgressCallback cb = {} );
 
// does not require closed surface, resulting grid cannot be used for boolean operations,
// surfaceOffset - the number of voxels around surface to calculate distance in (should be positive)
// returns null if was canceled by progress callback
MRVOXELS_API FloatGrid meshToDistanceField( const MeshPart& mp, const AffineXf3f& xf,
                                          const Vector3f& voxelSize, float surfaceOffset = 3,
                                          ProgressCallback cb = {} );
 
// Parameters structure for meshToVolume function
struct MeshToVolumeParams
{
    // Conversion type
    enum class Type
    {
        Signed, // only closed meshes can be converted with signed type
        Unsigned // this type leads to shell like iso-surfaces
    } type{ Type::Unsigned };
    float surfaceOffset{ 3.0 }; // the number of voxels around surface to calculate distance in (should be positive)
    Vector3f voxelSize = Vector3f::diagonal( 1.0f );
    AffineXf3f worldXf; // mesh initial transform
    AffineXf3f* outXf{ nullptr }; // optional output: xf to original mesh (respecting worldXf)
    ProgressCallback cb;
};
 
// eval min max value from FloatGrid
MRVOXELS_API void evalGridMinMax( const FloatGrid& grid, float& min, float& max );
 
MRVOXELS_API Expected<VdbVolume> meshToDistanceVdbVolume( const MeshPart& mp, const MeshToVolumeParams& params = {} );
 
MRVOXELS_API Expected<VdbVolume> meshToVolume( const MeshPart& mp, const MeshToVolumeParams& params = {} );
 
// fills VdbVolume data from FloatGrid (does not fill voxels size, cause we expect it outside)
MRVOXELS_API VdbVolume floatGridToVdbVolume( FloatGrid grid );
 
// make FloatGrid from SimpleVolume
// make copy of data
// background - the new background value for FloatGrid
// grid can be used to make iso-surface later with gridToMesh function
MRVOXELS_API FloatGrid simpleVolumeToDenseGrid( const SimpleVolume& simpleVolume, float background = 0.0f, ProgressCallback cb = {} );
// set the simpleVolume.min as the background value
MRVOXELS_API VdbVolume simpleVolumeToVdbVolume( const SimpleVolumeMinMax& simpleVolume, ProgressCallback cb = {} );
 
// make VdbVolume from FunctionVolume
// make copy of data
// set minimum value as the background value
MRVOXELS_API VdbVolume functionVolumeToVdbVolume( const FunctionVolume& functoinVolume, ProgressCallback cb = {} );
 
template <typename AccessorOrGrid>
MRVOXELS_API void putSimpleVolumeInDenseGrid(
        AccessorOrGrid& gridAccessor,
        const Vector3i& minCoord, const SimpleVolume& simpleVolume, ProgressCallback cb = {}
    );
 
// make SimpleVolume from VdbVolume
// make copy of data
MRVOXELS_API Expected<SimpleVolumeMinMax> vdbVolumeToSimpleVolume(
    const VdbVolume& vdbVolume, const Box3i& activeBox = Box3i(), ProgressCallback cb = {} );
MRVOXELS_API Expected<SimpleVolumeMinMax> vdbVolumeToSimpleVolumeNorm(
    const VdbVolume& vdbVolume, const Box3i& activeBox = Box3i(), std::optional<MinMaxf> sourceScale = {}, ProgressCallback cb = {} );
MRVOXELS_API Expected<SimpleVolumeMinMaxU16> vdbVolumeToSimpleVolumeU16(
    const VdbVolume& vdbVolume, const Box3i& activeBox = Box3i(), std::optional<MinMaxf> sourceScale = {}, ProgressCallback cb = {} );
 
struct GridToMeshSettings
{
    Vector3f voxelSize;
    float isoValue = 0;
    float adaptivity = 0;
    int maxFaces = INT_MAX;
    int maxVertices = INT_MAX;
    bool relaxDisorientedTriangles = true;
    ProgressCallback cb;
};
 
MRVOXELS_API Expected<Mesh> gridToMesh( const FloatGrid& grid, const GridToMeshSettings & settings );
 
MRVOXELS_API Expected<Mesh> gridToMesh( FloatGrid&& grid, const GridToMeshSettings & settings );
 
struct MakeSignedByWindingNumberSettings
{
    AffineXf3f meshToGridXf;
 
    std::shared_ptr<IFastWindingNumber> fwn;
 
    float windingNumberThreshold = 0.5f;
 
    float windingNumberBeta = 2;
 
    ProgressCallback progress;
};
 
MRVOXELS_API Expected<void> makeSignedByWindingNumber( FloatGrid& grid, const Vector3f& voxelSize, const Mesh& refMesh,
    const MakeSignedByWindingNumberSettings & settings );
 
struct DoubleOffsetSettings
{
    float voxelSize = 0;
 
    float offsetA = 0;
 
    float offsetB = 0;
 
    float adaptivity = 0;
 
    std::shared_ptr<IFastWindingNumber> fwn;
 
    float windingNumberThreshold = 0.5f;
 
    float windingNumberBeta = 2;
 
    ProgressCallback progress;
};
 
MRVOXELS_API Expected<Mesh> doubleOffsetVdb( const MeshPart& mp, const DoubleOffsetSettings & settings );
 
} //namespace MR