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 
{
 

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::ThickGyroid; 
    float frequency = 1.f; 
    float resolution = 5.f; 
};
 
struct MeshParams : VolumeParams
{
    float iso = 0.6f;
    bool decimate = true;
};

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 CellularSurface 
{

enum class Type : int
{
    Cylinder = 0,
    Rect
};
 
struct Params
{
    Type type = Type::Cylinder;                     
    Vector3f period = Vector3f::diagonal( 1.f );    
    Vector3f width = Vector3f::diagonal( 0.3f );    
    float r = 0.f;         

    bool highRes = false;

    bool preserveTips = false;
};

MRVOXELS_API std::vector<std::string> getTypeNames();
 

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 );

MRVOXELS_API std::optional<float> estimateWidth( float period, float r, float targetDensity );
 
}
 

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 = {} );
 

template <typename T>
struct MR_BIND_IGNORE ParamsFacade
{
    T params;
 
    Vector3f getPeriod() const
    {
        return std::visit( overloaded{
            [] ( const TPMS::MeshParams& p ){ return Vector3f::diagonal( 1.f / p.frequency ); },
            [] ( const CellularSurface::Params& p ) { return p.period; }
        }, params );
    }
};
 
ParamsFacade( MeshParamsRef ) -> ParamsFacade<MeshParamsRef>;
ParamsFacade( ConstMeshParamsRef ) -> ParamsFacade<ConstMeshParamsRef>;
 
}