MRVDBConversions.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshFwd.h"
#ifndef MRMESH_NO_OPENVDB
#include "MRMeshPart.h"
#include "MRProgressCallback.h"
#include "MRAffineXf3.h"
#include "MRExpected.h"
#include "MRBox.h"
#include <climits>
#include <string>
 
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
MRMESH_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
MRMESH_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
MRMESH_API void evalGridMinMax( const FloatGrid& grid, float& min, float& max );
 
// convert mesh to volume in (0,0,0)-(dim.x,dim.y,dim.z) grid box
MRMESH_API Expected<VdbVolume> meshToVolume( const Mesh& mesh, const MeshToVolumeParams& params = {} );
 
// fills VdbVolume data from FloatGrid (does not fill voxels size, cause we expect it outside)
MRMESH_API VdbVolume floatGridToVdbVolume( FloatGrid grid );
 
// make FloatGrid from SimpleVolume
// make copy of data
// grid can be used to make iso-surface later with gridToMesh function
MRMESH_API FloatGrid simpleVolumeToDenseGrid( const SimpleVolume& simpleVolume, ProgressCallback cb = {} );
MRMESH_API VdbVolume simpleVolumeToVdbVolume( const SimpleVolume& simpleVolume, ProgressCallback cb = {} );
 
// make SimpleVolume from VdbVolume
// make copy of data
MRMESH_API Expected<SimpleVolume> vdbVolumeToSimpleVolume(
    const VdbVolume& vdbVolume, const Box3i& activeBox = Box3i(), ProgressCallback cb = {} );
// make normalized SimpleVolume from VdbVolume
// make copy of data
MRMESH_API Expected<SimpleVolume> vdbVolumeToSimpleVolumeNorm(
    const VdbVolume& vdbVolume, const Box3i& activeBox = Box3i(), ProgressCallback cb = {} );
// make SimpleVolumeU16 from VdbVolume
// performs mapping from [vdbVolume.min, vdbVolume.max] to nonnegative range of uint16_t
MRMESH_API Expected<SimpleVolumeU16> vdbVolumeToSimpleVolumeU16(
    const VdbVolume& vdbVolume, const Box3i& activeBox = Box3i(), 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;
};
 
MRMESH_API Expected<Mesh> gridToMesh( const FloatGrid& grid, const GridToMeshSettings & settings );
 
MRMESH_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;
};
 
MRMESH_API VoidOrErrStr 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;
};
 
MRMESH_API Expected<Mesh> doubleOffsetVdb( const MeshPart& mp, const DoubleOffsetSettings & settings );
 
} //namespace MR
#endif