MRFillingSurface.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMesh/MRVector3.h>
#include <MRCMisc/common.h>
#include <MRCMisc/exports.h>
 
#include <stdbool.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct MR_FunctionVolume MR_FunctionVolume; // Defined in `#include <MRCVoxels/MRVoxelsVolume.h>`.
typedef struct MR_Mesh MR_Mesh; // Defined in `#include <MRCMesh/MRMesh.h>`.
typedef struct MR_expected_MR_Mesh_std_string MR_expected_MR_Mesh_std_string; // Defined in `#include <MRCMisc/expected_MR_Mesh_std_string.h>`.
typedef struct MR_std_function_bool_from_float MR_std_function_bool_from_float; // Defined in `#include <MRCMisc/std_function_bool_from_float.h>`.
typedef struct MR_std_optional_float MR_std_optional_float; // Defined in `#include <MRCMisc/std_optional_float.h>`.
typedef struct MR_std_vector_std_string MR_std_vector_std_string; // Defined in `#include <MRCMisc/std_vector_std_string.h>`.
 
 
typedef enum MR_FillingSurface_TPMS_Type
{
    MR_FillingSurface_TPMS_Type_SchwartzP = 0,
    MR_FillingSurface_TPMS_Type_ThickSchwartzP = 1,
    MR_FillingSurface_TPMS_Type_DoubleGyroid = 2,
    MR_FillingSurface_TPMS_Type_ThickGyroid = 3,
    MR_FillingSurface_TPMS_Type_Count = 4,
} MR_FillingSurface_TPMS_Type;
 
typedef struct MR_FillingSurface_TPMS_VolumeParams MR_FillingSurface_TPMS_VolumeParams;
 
typedef struct MR_FillingSurface_TPMS_MeshParams MR_FillingSurface_TPMS_MeshParams;
 
typedef enum MR_FillingSurface_CellularSurface_Type
{
    MR_FillingSurface_CellularSurface_Type_Cylinder = 0,
    MR_FillingSurface_CellularSurface_Type_Rect = 1,
} MR_FillingSurface_CellularSurface_Type;
 
typedef struct MR_FillingSurface_CellularSurface_Params MR_FillingSurface_CellularSurface_Params;
 
// Different kinds of filling surface
typedef enum MR_FillingSurface_Kind
{
    MR_FillingSurface_Kind_TPMS = 0,
    MR_FillingSurface_Kind_Cellular = 1,
} MR_FillingSurface_Kind;
 
MRC_API MR_std_vector_std_string *MR_FillingSurface_TPMS_getTypeNames(void);
 
MRC_API MR_std_vector_std_string *MR_FillingSurface_TPMS_getTypeTooltips(void);
 
MRC_API bool MR_FillingSurface_TPMS_isThick(MR_FillingSurface_TPMS_Type type);
 
// Type of the surface
MRC_API const MR_FillingSurface_TPMS_Type *MR_FillingSurface_TPMS_VolumeParams_Get_type(const MR_FillingSurface_TPMS_VolumeParams *_this);
 
// Type of the surface
MRC_API void MR_FillingSurface_TPMS_VolumeParams_Set_type(MR_FillingSurface_TPMS_VolumeParams *_this, MR_FillingSurface_TPMS_Type value);
 
// Type of the surface
MRC_API MR_FillingSurface_TPMS_Type *MR_FillingSurface_TPMS_VolumeParams_GetMutable_type(MR_FillingSurface_TPMS_VolumeParams *_this);
 
// Frequency of oscillations (determines size of the "cells" in the "grid")
MRC_API const float *MR_FillingSurface_TPMS_VolumeParams_Get_frequency(const MR_FillingSurface_TPMS_VolumeParams *_this);
 
// Frequency of oscillations (determines size of the "cells" in the "grid")
MRC_API void MR_FillingSurface_TPMS_VolumeParams_Set_frequency(MR_FillingSurface_TPMS_VolumeParams *_this, float value);
 
// Frequency of oscillations (determines size of the "cells" in the "grid")
MRC_API float *MR_FillingSurface_TPMS_VolumeParams_GetMutable_frequency(MR_FillingSurface_TPMS_VolumeParams *_this);
 
// Ratio `n / T`, between the number of voxels and period of oscillations
MRC_API const float *MR_FillingSurface_TPMS_VolumeParams_Get_resolution(const MR_FillingSurface_TPMS_VolumeParams *_this);
 
// Ratio `n / T`, between the number of voxels and period of oscillations
MRC_API void MR_FillingSurface_TPMS_VolumeParams_Set_resolution(MR_FillingSurface_TPMS_VolumeParams *_this, float value);
 
// Ratio `n / T`, between the number of voxels and period of oscillations
MRC_API float *MR_FillingSurface_TPMS_VolumeParams_GetMutable_resolution(MR_FillingSurface_TPMS_VolumeParams *_this);
 
MRC_API MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_VolumeParams_DefaultConstruct(void);
 
MRC_API MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_VolumeParams_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_VolumeParams_ConstructFrom(MR_FillingSurface_TPMS_Type type, float frequency, float resolution);
 
MRC_API const MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_VolumeParams_OffsetPtr(const MR_FillingSurface_TPMS_VolumeParams *ptr, ptrdiff_t i);
 
MRC_API MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_VolumeParams_OffsetMutablePtr(MR_FillingSurface_TPMS_VolumeParams *ptr, ptrdiff_t i);
 
MRC_API const MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_VolumeParams_StaticDowncastTo_MR_FillingSurface_TPMS_MeshParams(const MR_FillingSurface_TPMS_VolumeParams *object);
 
MRC_API MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_VolumeParams_MutableStaticDowncastTo_MR_FillingSurface_TPMS_MeshParams(MR_FillingSurface_TPMS_VolumeParams *object);
 
MRC_API MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_VolumeParams_ConstructFromAnother(const MR_FillingSurface_TPMS_VolumeParams *_other);
 
MRC_API void MR_FillingSurface_TPMS_VolumeParams_Destroy(const MR_FillingSurface_TPMS_VolumeParams *_this);
 
MRC_API void MR_FillingSurface_TPMS_VolumeParams_DestroyArray(const MR_FillingSurface_TPMS_VolumeParams *_this);
 
MRC_API MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_VolumeParams_AssignFromAnother(MR_FillingSurface_TPMS_VolumeParams *_this, const MR_FillingSurface_TPMS_VolumeParams *_other);
 
MRC_API const float *MR_FillingSurface_TPMS_MeshParams_Get_iso(const MR_FillingSurface_TPMS_MeshParams *_this);
 
MRC_API void MR_FillingSurface_TPMS_MeshParams_Set_iso(MR_FillingSurface_TPMS_MeshParams *_this, float value);
 
MRC_API float *MR_FillingSurface_TPMS_MeshParams_GetMutable_iso(MR_FillingSurface_TPMS_MeshParams *_this);
 
MRC_API const bool *MR_FillingSurface_TPMS_MeshParams_Get_decimate(const MR_FillingSurface_TPMS_MeshParams *_this);
 
MRC_API void MR_FillingSurface_TPMS_MeshParams_Set_decimate(MR_FillingSurface_TPMS_MeshParams *_this, bool value);
 
MRC_API bool *MR_FillingSurface_TPMS_MeshParams_GetMutable_decimate(MR_FillingSurface_TPMS_MeshParams *_this);
 
// Type of the surface
MRC_API const MR_FillingSurface_TPMS_Type *MR_FillingSurface_TPMS_MeshParams_Get_type(const MR_FillingSurface_TPMS_MeshParams *_this);
 
// Type of the surface
MRC_API void MR_FillingSurface_TPMS_MeshParams_Set_type(MR_FillingSurface_TPMS_MeshParams *_this, MR_FillingSurface_TPMS_Type value);
 
// Type of the surface
MRC_API MR_FillingSurface_TPMS_Type *MR_FillingSurface_TPMS_MeshParams_GetMutable_type(MR_FillingSurface_TPMS_MeshParams *_this);
 
// Frequency of oscillations (determines size of the "cells" in the "grid")
MRC_API const float *MR_FillingSurface_TPMS_MeshParams_Get_frequency(const MR_FillingSurface_TPMS_MeshParams *_this);
 
// Frequency of oscillations (determines size of the "cells" in the "grid")
MRC_API void MR_FillingSurface_TPMS_MeshParams_Set_frequency(MR_FillingSurface_TPMS_MeshParams *_this, float value);
 
// Frequency of oscillations (determines size of the "cells" in the "grid")
MRC_API float *MR_FillingSurface_TPMS_MeshParams_GetMutable_frequency(MR_FillingSurface_TPMS_MeshParams *_this);
 
// Ratio `n / T`, between the number of voxels and period of oscillations
MRC_API const float *MR_FillingSurface_TPMS_MeshParams_Get_resolution(const MR_FillingSurface_TPMS_MeshParams *_this);
 
// Ratio `n / T`, between the number of voxels and period of oscillations
MRC_API void MR_FillingSurface_TPMS_MeshParams_Set_resolution(MR_FillingSurface_TPMS_MeshParams *_this, float value);
 
// Ratio `n / T`, between the number of voxels and period of oscillations
MRC_API float *MR_FillingSurface_TPMS_MeshParams_GetMutable_resolution(MR_FillingSurface_TPMS_MeshParams *_this);
 
MRC_API MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_MeshParams_DefaultConstruct(void);
 
MRC_API MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_MeshParams_DefaultConstructArray(size_t num_elems);
 
MRC_API const MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_MeshParams_OffsetPtr(const MR_FillingSurface_TPMS_MeshParams *ptr, ptrdiff_t i);
 
MRC_API MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_MeshParams_OffsetMutablePtr(MR_FillingSurface_TPMS_MeshParams *ptr, ptrdiff_t i);
 
MRC_API const MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_MeshParams_UpcastTo_MR_FillingSurface_TPMS_VolumeParams(const MR_FillingSurface_TPMS_MeshParams *object);
 
MRC_API MR_FillingSurface_TPMS_VolumeParams *MR_FillingSurface_TPMS_MeshParams_MutableUpcastTo_MR_FillingSurface_TPMS_VolumeParams(MR_FillingSurface_TPMS_MeshParams *object);
 
MRC_API MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_MeshParams_ConstructFromAnother(const MR_FillingSurface_TPMS_MeshParams *_other);
 
MRC_API void MR_FillingSurface_TPMS_MeshParams_Destroy(const MR_FillingSurface_TPMS_MeshParams *_this);
 
MRC_API void MR_FillingSurface_TPMS_MeshParams_DestroyArray(const MR_FillingSurface_TPMS_MeshParams *_this);
 
MRC_API MR_FillingSurface_TPMS_MeshParams *MR_FillingSurface_TPMS_MeshParams_AssignFromAnother(MR_FillingSurface_TPMS_MeshParams *_this, const MR_FillingSurface_TPMS_MeshParams *_other);
 
MRC_API MR_FunctionVolume *MR_FillingSurface_TPMS_buildVolume(const MR_Vector3f *size, const MR_FillingSurface_TPMS_VolumeParams *params);
 
MRC_API MR_expected_MR_Mesh_std_string *MR_FillingSurface_TPMS_build(const MR_Vector3f *size, const MR_FillingSurface_TPMS_MeshParams *params, MR_PassBy cb_pass_by, MR_std_function_bool_from_float *cb);
 
MRC_API MR_expected_MR_Mesh_std_string *MR_FillingSurface_TPMS_fill(const MR_Mesh *mesh, const MR_FillingSurface_TPMS_MeshParams *params, MR_PassBy cb_pass_by, MR_std_function_bool_from_float *cb);
 
MRC_API MR_uint64_t MR_FillingSurface_TPMS_getNumberOfVoxels_MR_Mesh(const MR_Mesh *mesh, float frequency, float resolution);
 
MRC_API MR_uint64_t MR_FillingSurface_TPMS_getNumberOfVoxels_MR_Vector3f(const MR_Vector3f *size, float frequency, float resolution);
 
MRC_API float MR_FillingSurface_TPMS_estimateIso(MR_FillingSurface_TPMS_Type type, float targetDensity);
 
MRC_API float MR_FillingSurface_TPMS_estimateDensity(MR_FillingSurface_TPMS_Type type, float targetIso);
 
MRC_API float MR_FillingSurface_TPMS_getMinimalResolution(MR_FillingSurface_TPMS_Type type, float iso);
 
MRC_API const MR_FillingSurface_CellularSurface_Type *MR_FillingSurface_CellularSurface_Params_Get_type(const MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API void MR_FillingSurface_CellularSurface_Params_Set_type(MR_FillingSurface_CellularSurface_Params *_this, MR_FillingSurface_CellularSurface_Type value);
 
MRC_API MR_FillingSurface_CellularSurface_Type *MR_FillingSurface_CellularSurface_Params_GetMutable_type(MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API const MR_Vector3f *MR_FillingSurface_CellularSurface_Params_Get_period(const MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API void MR_FillingSurface_CellularSurface_Params_Set_period(MR_FillingSurface_CellularSurface_Params *_this, MR_Vector3f value);
 
MRC_API MR_Vector3f *MR_FillingSurface_CellularSurface_Params_GetMutable_period(MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API const MR_Vector3f *MR_FillingSurface_CellularSurface_Params_Get_width(const MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API void MR_FillingSurface_CellularSurface_Params_Set_width(MR_FillingSurface_CellularSurface_Params *_this, MR_Vector3f value);
 
MRC_API MR_Vector3f *MR_FillingSurface_CellularSurface_Params_GetMutable_width(MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API const float *MR_FillingSurface_CellularSurface_Params_Get_r(const MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API void MR_FillingSurface_CellularSurface_Params_Set_r(MR_FillingSurface_CellularSurface_Params *_this, float value);
 
MRC_API float *MR_FillingSurface_CellularSurface_Params_GetMutable_r(MR_FillingSurface_CellularSurface_Params *_this);
 
// used in tests in order to make surfaces close to their analytical expression
// recommended to be false for real usage for better performance
MRC_API const bool *MR_FillingSurface_CellularSurface_Params_Get_highRes(const MR_FillingSurface_CellularSurface_Params *_this);
 
// used in tests in order to make surfaces close to their analytical expression
// recommended to be false for real usage for better performance
MRC_API void MR_FillingSurface_CellularSurface_Params_Set_highRes(MR_FillingSurface_CellularSurface_Params *_this, bool value);
 
// used in tests in order to make surfaces close to their analytical expression
// recommended to be false for real usage for better performance
MRC_API bool *MR_FillingSurface_CellularSurface_Params_GetMutable_highRes(MR_FillingSurface_CellularSurface_Params *_this);
 
// Used in tests for roughly the same purpose: the computations of density estimation are made under the assumption of an infinite surface.
// Thus, we must impose "boundary conditions" that inflict the "tips" of the bars (cylinders or cubes) to be preserved on the boundary of the
// generated filling surface. However, for the aesthetic reasons, it was requested that the tips must be cut in the UI. And here comes this flag.
// Note that for the estimation of density in UI the influence of "tips" is not significant (it tends to zero with growing size), however
// we cannot afford to run tests on too big surfaces as it takes too long.
MRC_API const bool *MR_FillingSurface_CellularSurface_Params_Get_preserveTips(const MR_FillingSurface_CellularSurface_Params *_this);
 
// Used in tests for roughly the same purpose: the computations of density estimation are made under the assumption of an infinite surface.
// Thus, we must impose "boundary conditions" that inflict the "tips" of the bars (cylinders or cubes) to be preserved on the boundary of the
// generated filling surface. However, for the aesthetic reasons, it was requested that the tips must be cut in the UI. And here comes this flag.
// Note that for the estimation of density in UI the influence of "tips" is not significant (it tends to zero with growing size), however
// we cannot afford to run tests on too big surfaces as it takes too long.
MRC_API void MR_FillingSurface_CellularSurface_Params_Set_preserveTips(MR_FillingSurface_CellularSurface_Params *_this, bool value);
 
// Used in tests for roughly the same purpose: the computations of density estimation are made under the assumption of an infinite surface.
// Thus, we must impose "boundary conditions" that inflict the "tips" of the bars (cylinders or cubes) to be preserved on the boundary of the
// generated filling surface. However, for the aesthetic reasons, it was requested that the tips must be cut in the UI. And here comes this flag.
// Note that for the estimation of density in UI the influence of "tips" is not significant (it tends to zero with growing size), however
// we cannot afford to run tests on too big surfaces as it takes too long.
MRC_API bool *MR_FillingSurface_CellularSurface_Params_GetMutable_preserveTips(MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API MR_FillingSurface_CellularSurface_Params *MR_FillingSurface_CellularSurface_Params_DefaultConstruct(void);
 
MRC_API MR_FillingSurface_CellularSurface_Params *MR_FillingSurface_CellularSurface_Params_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_FillingSurface_CellularSurface_Params *MR_FillingSurface_CellularSurface_Params_ConstructFrom(MR_FillingSurface_CellularSurface_Type type, MR_Vector3f period, MR_Vector3f width, float r, bool highRes, bool preserveTips);
 
MRC_API const MR_FillingSurface_CellularSurface_Params *MR_FillingSurface_CellularSurface_Params_OffsetPtr(const MR_FillingSurface_CellularSurface_Params *ptr, ptrdiff_t i);
 
MRC_API MR_FillingSurface_CellularSurface_Params *MR_FillingSurface_CellularSurface_Params_OffsetMutablePtr(MR_FillingSurface_CellularSurface_Params *ptr, ptrdiff_t i);
 
MRC_API MR_FillingSurface_CellularSurface_Params *MR_FillingSurface_CellularSurface_Params_ConstructFromAnother(const MR_FillingSurface_CellularSurface_Params *_other);
 
MRC_API void MR_FillingSurface_CellularSurface_Params_Destroy(const MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API void MR_FillingSurface_CellularSurface_Params_DestroyArray(const MR_FillingSurface_CellularSurface_Params *_this);
 
MRC_API MR_FillingSurface_CellularSurface_Params *MR_FillingSurface_CellularSurface_Params_AssignFromAnother(MR_FillingSurface_CellularSurface_Params *_this, const MR_FillingSurface_CellularSurface_Params *_other);
 
MRC_API MR_std_vector_std_string *MR_FillingSurface_CellularSurface_getTypeNames(void);
 
MRC_API MR_expected_MR_Mesh_std_string *MR_FillingSurface_CellularSurface_build(const MR_Vector3f *size, const MR_FillingSurface_CellularSurface_Params *params, const MR_std_function_bool_from_float *cb);
 
MRC_API MR_expected_MR_Mesh_std_string *MR_FillingSurface_CellularSurface_fill(const MR_Mesh *mesh, const MR_FillingSurface_CellularSurface_Params *params, const MR_std_function_bool_from_float *cb);
 
MRC_API float MR_FillingSurface_CellularSurface_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.
MRC_API MR_std_optional_float *MR_FillingSurface_CellularSurface_estimateWidth(float period, float r, float targetDensity);
 
MRC_API MR_std_vector_std_string *MR_FillingSurface_getKindNames(void);
 
#ifdef __cplusplus
} // extern "C"
#endif