MRMarchingCubes.h

Go to the documentation of this file.

#pragma once
 
#include "MRVoxelsFwd.h"
#include "MRMesh/MRAffineXf3.h"
#include "MRVoxelsVolume.h"
#include "MRMesh/MRProgressCallback.h"
#include "MRMesh/MRSignDetectionMode.h"
#include "MRMesh/MRExpected.h"
#include <climits>
 
namespace MR
{
 
// Callback type for positioning marching cubes vertices
// args: position0, position1, value0, value1, iso
using VoxelPointPositioner = std::function<Vector3f( const Vector3f&, const Vector3f&, float, float, float )>;
 
struct MarchingCubesParams
{
    Vector3f origin;
 
    ProgressCallback cb;
 
    float iso{ 0.0f };
 
    bool lessInside{ false };
 
    Vector<VoxelId, FaceId>* outVoxelPerFaceMap{ nullptr };
 
    VoxelPointPositioner positioner = {};
 
    int maxVertices = INT_MAX;
 
    enum class CachingMode
    {
        Automatic,
        None,
        Normal,
    } cachingMode = CachingMode::Automatic;
 
    std::function<void()> freeVolume;
 
    // To allow passing Python lambdas into `positioner`.
    MR_BIND_PREFER_UNLOCK_GIL_WHEN_USED_AS_PARAM
};
 
// makes Mesh from SimpleVolume with given settings using Marching Cubes algorithm
MRVOXELS_API Expected<Mesh> marchingCubes( const SimpleVolume& volume, const MarchingCubesParams& params = {} );
MRVOXELS_API Expected<TriMesh> marchingCubesAsTriMesh( const SimpleVolume& volume, const MarchingCubesParams& params = {} );
 
// makes Mesh from SimpleVolumeMinMax with given settings using Marching Cubes algorithm
MRVOXELS_API Expected<Mesh> marchingCubes( const SimpleVolumeMinMax& volume, const MarchingCubesParams& params = {} );
MRVOXELS_API Expected<TriMesh> marchingCubesAsTriMesh( const SimpleVolumeMinMax& volume, const MarchingCubesParams& params = {} );
 
// makes Mesh from VdbVolume with given settings using Marching Cubes algorithm
MRVOXELS_API Expected<Mesh> marchingCubes( const VdbVolume& volume, const MarchingCubesParams& params = {} );
MRVOXELS_API Expected<TriMesh> marchingCubesAsTriMesh( const VdbVolume& volume, const MarchingCubesParams& params = {} );
 
// makes Mesh from FunctionVolume with given settings using Marching Cubes algorithm
MRVOXELS_API Expected<Mesh> marchingCubes( const FunctionVolume& volume, const MarchingCubesParams& params = {} );
MRVOXELS_API Expected<TriMesh> marchingCubesAsTriMesh( const FunctionVolume& volume, const MarchingCubesParams& params = {} );
 
// makes Mesh from SimpleBinaryVolume with given settings using Marching Cubes algorithm
MRVOXELS_API Expected<Mesh> marchingCubes( const SimpleBinaryVolume& volume, const MarchingCubesParams& params = {} );
MRVOXELS_API Expected<TriMesh> marchingCubesAsTriMesh( const SimpleBinaryVolume& volume, const MarchingCubesParams& params = {} );
 
class MarchingCubesByParts
{
public:
    MRVOXELS_API explicit MarchingCubesByParts( const Vector3i & dims, const MarchingCubesParams& params, int layersPerBlock = 0 );
 
    MRVOXELS_API ~MarchingCubesByParts();
    MRVOXELS_API MarchingCubesByParts( MarchingCubesByParts && s ) noexcept;
    MRVOXELS_API MarchingCubesByParts & operator=( MarchingCubesByParts && s ) noexcept;
 
    MRVOXELS_API int layersPerBlock() const;
 
    MRVOXELS_API int nextZ() const;
 
    MRVOXELS_API Expected<void> addPart( const SimpleVolume& part );
 
    MRVOXELS_API Expected<TriMesh> finalize();
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
} //namespace MR