MRFillingSurface.h

Go to the documentation of this file.

#pragma once
 
#include <MRMesh/MRMeshFwd.h>
#include <MRMesh/MRExpected.h>
#include <MRMesh/MRVector3.h>
#include <MRVoxels/MRVoxelsFwd.h>
 
#include <variant>
#include <optional>
 
namespace MR::FillingSurface
{
 
namespace TPMS // Triply Periodic Minimal Surface
{
 
 
enum class Type : int
{
    SchwartzP,
    ThickSchwartzP,
    DoubleGyroid,
    ThickGyroid,
 
    Count
};
 
MRVOXELS_API std::vector<std::string> getTypeNames();
 
MRVOXELS_API std::vector<std::string> getTypeTooltips();
 
MRVOXELS_API bool isThick( Type type );
 
 
struct VolumeParams
{
    Type type = Type::SchwartzP; // Type of the surface
    float frequency = 1.f; // Frequency of oscillations (determines size of the "cells" in the "grid")
    float resolution = 5.f; // Ratio `n / T`, between the number of voxels and period of oscillations
};
 
struct MeshParams : VolumeParams
{
    float iso = 0.f;
    bool decimate = false;
};
 
MRVOXELS_API FunctionVolume buildVolume( const Vector3f& size, const VolumeParams& params );
 
MRVOXELS_API Expected<Mesh> build( const Vector3f& size, const MeshParams& params, ProgressCallback cb = {} );
 
MRVOXELS_API Expected<Mesh> fill( const Mesh& mesh, const MeshParams& params, ProgressCallback cb = {} );
 
MRVOXELS_API size_t getNumberOfVoxels( const Mesh& mesh, float frequency, float resolution );
 
MRVOXELS_API size_t getNumberOfVoxels( const Vector3f& size, float frequency, float resolution );
 
MRVOXELS_API float estimateIso( Type type, float targetDensity );
 
MRVOXELS_API float estimateDensity( Type type, float targetIso );
 
MRVOXELS_API float getMinimalResolution( Type type, float iso );
 
} // namespace TPMS
 
 
 
namespace CellularSurface // Surface of cylinders in a grid
{
 
struct Params
{
    Vector3f period = Vector3f::diagonal( 1.f );    
    Vector3f width = Vector3f::diagonal( 0.3f );    
    float r = 0.4f;         
 
    // used in tests in order to make surfaces close to their analytical expression
    // recommended to be false for real usage for better performance
    bool highRes = false;
 
};
 
MRVOXELS_API Expected<Mesh> build( const Vector3f& size, const Params& params, const ProgressCallback& cb = {} );
 
MRVOXELS_API Expected<Mesh> fill( const Mesh& mesh, const Params& params, const ProgressCallback& cb = {} );
 
MRVOXELS_API float estimateDensity( float period, float width, float r );
 
//    Due to the simplification of the formula (sphere must either fully contain the intersection of cylinders or be inside it), solution not always exists.
MRVOXELS_API std::optional<float> estimateWidth( float period, float r, float targetDensity );
 
}
 
 
// Different kinds of filling surface
enum class Kind : int
{
    TPMS = 0,
    Cellular
};
MRVOXELS_API std::vector<std::string> getKindNames();
 
using MeshParamsRef = std::variant
    < std::reference_wrapper<TPMS::MeshParams>
    , std::reference_wrapper<CellularSurface::Params>
    >;
 
using ConstMeshParamsRef = std::variant
    < std::reference_wrapper<const TPMS::MeshParams>
    , std::reference_wrapper<const CellularSurface::Params>
    >;
 
MR_BIND_IGNORE MRVOXELS_API Expected<Mesh> build( const Vector3f& size, ConstMeshParamsRef params, ProgressCallback cb = {} );
MR_BIND_IGNORE MRVOXELS_API Expected<Mesh> fill( const Mesh& mesh, ConstMeshParamsRef params, ProgressCallback cb = {} );
 
} // namespace FillingSurface