MRMoveMeshToVoxelMaxDeriv.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMesh/MRAffineXf.h>
#include <MRCMesh/MRId.h>
#include <MRCMesh/MRVector3.h>
#include <MRCMisc/common.h>
#include <MRCMisc/exports.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_PolynomialWrapper_float MR_PolynomialWrapper_float; // Defined in `#include <MRCMesh/MRBestFitPolynomial.h>`.
typedef struct MR_SimpleVolumeMinMax MR_SimpleVolumeMinMax; // Defined in `#include <MRCVoxels/MRVoxelsVolume.h>`.
typedef struct MR_VdbVolume MR_VdbVolume; // Defined in `#include <MRCVoxels/MRVoxelsVolume.h>`.
typedef struct MR_expected_MR_VertBitSet_std_string MR_expected_MR_VertBitSet_std_string; // Defined in `#include <MRCMisc/expected_MR_VertBitSet_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_vector_MR_Vector3f MR_std_vector_MR_Vector3f; // Defined in `#include <MRCMisc/std_vector_MR_Vector3f.h>`.
typedef struct MR_std_vector_float MR_std_vector_float; // Defined in `#include <MRCMisc/std_vector_float.h>`.
 
 
typedef struct MR_MoveMeshToVoxelMaxDerivSettings MR_MoveMeshToVoxelMaxDerivSettings;
 
typedef struct MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume;
 
typedef struct MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume;
 
typedef struct MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax;
 
typedef struct MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax;
 
typedef struct MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume;
 
typedef struct MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume;
 
MRC_API const int *MR_MoveMeshToVoxelMaxDerivSettings_Get_iters(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_Set_iters(MR_MoveMeshToVoxelMaxDerivSettings *_this, int value);
 
MRC_API int *MR_MoveMeshToVoxelMaxDerivSettings_GetMutable_iters(MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API const int *MR_MoveMeshToVoxelMaxDerivSettings_Get_samplePoints(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_Set_samplePoints(MR_MoveMeshToVoxelMaxDerivSettings *_this, int value);
 
MRC_API int *MR_MoveMeshToVoxelMaxDerivSettings_GetMutable_samplePoints(MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API const int *MR_MoveMeshToVoxelMaxDerivSettings_Get_degree(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_Set_degree(MR_MoveMeshToVoxelMaxDerivSettings *_this, int value);
 
MRC_API int *MR_MoveMeshToVoxelMaxDerivSettings_GetMutable_degree(MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API const float *MR_MoveMeshToVoxelMaxDerivSettings_Get_outlierThreshold(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_Set_outlierThreshold(MR_MoveMeshToVoxelMaxDerivSettings *_this, float value);
 
MRC_API float *MR_MoveMeshToVoxelMaxDerivSettings_GetMutable_outlierThreshold(MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API const float *MR_MoveMeshToVoxelMaxDerivSettings_Get_intermediateSmoothForce(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_Set_intermediateSmoothForce(MR_MoveMeshToVoxelMaxDerivSettings *_this, float value);
 
MRC_API float *MR_MoveMeshToVoxelMaxDerivSettings_GetMutable_intermediateSmoothForce(MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API const float *MR_MoveMeshToVoxelMaxDerivSettings_Get_preparationSmoothForce(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_Set_preparationSmoothForce(MR_MoveMeshToVoxelMaxDerivSettings *_this, float value);
 
MRC_API float *MR_MoveMeshToVoxelMaxDerivSettings_GetMutable_preparationSmoothForce(MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API MR_MoveMeshToVoxelMaxDerivSettings *MR_MoveMeshToVoxelMaxDerivSettings_DefaultConstruct(void);
 
MRC_API MR_MoveMeshToVoxelMaxDerivSettings *MR_MoveMeshToVoxelMaxDerivSettings_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_MoveMeshToVoxelMaxDerivSettings *MR_MoveMeshToVoxelMaxDerivSettings_ConstructFrom(int iters, int samplePoints, int degree, float outlierThreshold, float intermediateSmoothForce, float preparationSmoothForce);
 
MRC_API const MR_MoveMeshToVoxelMaxDerivSettings *MR_MoveMeshToVoxelMaxDerivSettings_OffsetPtr(const MR_MoveMeshToVoxelMaxDerivSettings *ptr, ptrdiff_t i);
 
MRC_API MR_MoveMeshToVoxelMaxDerivSettings *MR_MoveMeshToVoxelMaxDerivSettings_OffsetMutablePtr(MR_MoveMeshToVoxelMaxDerivSettings *ptr, ptrdiff_t i);
 
MRC_API MR_MoveMeshToVoxelMaxDerivSettings *MR_MoveMeshToVoxelMaxDerivSettings_ConstructFromAnother(const MR_MoveMeshToVoxelMaxDerivSettings *_other);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_Destroy(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API void MR_MoveMeshToVoxelMaxDerivSettings_DestroyArray(const MR_MoveMeshToVoxelMaxDerivSettings *_this);
 
MRC_API MR_MoveMeshToVoxelMaxDerivSettings *MR_MoveMeshToVoxelMaxDerivSettings_AssignFromAnother(MR_MoveMeshToVoxelMaxDerivSettings *_this, const MR_MoveMeshToVoxelMaxDerivSettings *_other);
 
MRC_API MR_expected_MR_VertBitSet_std_string *MR_moveMeshToVoxelMaxDeriv_MR_VdbVolume(MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_VdbVolume *volume, const MR_AffineXf3f *volumeXf, const MR_MoveMeshToVoxelMaxDerivSettings *settings, MR_PassBy callback_pass_by, MR_std_function_bool_from_float *callback);
 
MRC_API MR_expected_MR_VertBitSet_std_string *MR_moveMeshToVoxelMaxDeriv_MR_SimpleVolumeMinMax(MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_SimpleVolumeMinMax *volume, const MR_AffineXf3f *volumeXf, const MR_MoveMeshToVoxelMaxDerivSettings *settings, MR_PassBy callback_pass_by, MR_std_function_bool_from_float *callback);
 
MRC_API MR_expected_MR_VertBitSet_std_string *MR_moveMeshToVoxelMaxDeriv_MR_FunctionVolume(MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_FunctionVolume *volume, const MR_AffineXf3f *volumeXf, const MR_MoveMeshToVoxelMaxDerivSettings *settings, MR_PassBy callback_pass_by, MR_std_function_bool_from_float *callback);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_ConstructFromAnother(MR_PassBy other_pass_by, MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *other);
 
MRC_API const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_OffsetPtr(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_OffsetMutablePtr(MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_Construct(MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_VdbVolume *volume, const MR_AffineXf3f *volumeXf);
 
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_Destroy(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_DestroyArray(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
// Access to base data
MRC_API MR_Mesh *MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_mesh(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API const MR_VdbVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_volume(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
// Cached number of valid vertices
MRC_API int MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_numVerts(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
// Voxel size as scalar
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_voxelSize(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
// Transformation mesh to volume
// All points are in voxels volume space, unless otherwise is implied
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_xf_0(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_xf_1(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this, const MR_Vector3f *pt);
 
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_xfInv_0(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_xfInv_1(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this, const MR_Vector3f *pt);
 
// Vertex position
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_point(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this, MR_VertId v);
 
// Volume value
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_getValue(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this, const MR_Vector3f *pos);
 
// Get offset vector (mesh normal for a vertex with `voxelSize` length)
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_getOffsetVector(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this, MR_VertId v);
 
// Get a pseudo-index for a zero-based point index in a zero-centered row of `count` points
// Pseudo-index is a signed number; for whole index, is is whole or half-whole
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_pseudoIndex_float(float index, int count);
 
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_pseudoIndex_int(int index, int count);
 
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_indexFromPseudoIndex(float pseudoIndex, int count);
 
// Get row of points with `offset` stride
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_getPoints(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this, MR_std_vector_MR_Vector3f *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get volume values for a row of points
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_getValues(const MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume *_this, MR_std_vector_float *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get derivatives from result of `getValues`
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_getDerivatives(MR_std_vector_float *result, const MR_std_vector_float *values);
 
MRC_API MR_PolynomialWrapper_float *MR_MeshOnVoxelsT_MR_Mesh_MR_VdbVolume_getBestPolynomial(const MR_std_vector_float *values, MR_uint64_t degree);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_ConstructFromAnother(MR_PassBy other_pass_by, MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *other);
 
MRC_API const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_OffsetPtr(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_OffsetMutablePtr(MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_Construct(const MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_VdbVolume *volume, const MR_AffineXf3f *volumeXf);
 
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_Destroy(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_DestroyArray(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
// Access to base data
MRC_API const MR_Mesh *MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_mesh(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API const MR_VdbVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_volume(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
// Cached number of valid vertices
MRC_API int MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_numVerts(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
// Voxel size as scalar
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_voxelSize(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
// Transformation mesh to volume
// All points are in voxels volume space, unless otherwise is implied
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_xf_0(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_xf_1(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this, const MR_Vector3f *pt);
 
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_xfInv_0(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_xfInv_1(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this, const MR_Vector3f *pt);
 
// Vertex position
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_point(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this, MR_VertId v);
 
// Volume value
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_getValue(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this, const MR_Vector3f *pos);
 
// Get offset vector (mesh normal for a vertex with `voxelSize` length)
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_getOffsetVector(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this, MR_VertId v);
 
// Get a pseudo-index for a zero-based point index in a zero-centered row of `count` points
// Pseudo-index is a signed number; for whole index, is is whole or half-whole
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_pseudoIndex_float(float index, int count);
 
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_pseudoIndex_int(int index, int count);
 
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_indexFromPseudoIndex(float pseudoIndex, int count);
 
// Get row of points with `offset` stride
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_getPoints(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this, MR_std_vector_MR_Vector3f *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get volume values for a row of points
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_getValues(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume *_this, MR_std_vector_float *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get derivatives from result of `getValues`
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_getDerivatives(MR_std_vector_float *result, const MR_std_vector_float *values);
 
MRC_API MR_PolynomialWrapper_float *MR_MeshOnVoxelsT_const_MR_Mesh_MR_VdbVolume_getBestPolynomial(const MR_std_vector_float *values, MR_uint64_t degree);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_ConstructFromAnother(MR_PassBy other_pass_by, MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *other);
 
MRC_API const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_OffsetPtr(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_OffsetMutablePtr(MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_Construct(MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_SimpleVolumeMinMax *volume, const MR_AffineXf3f *volumeXf);
 
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_Destroy(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_DestroyArray(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Access to base data
MRC_API MR_Mesh *MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_mesh(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API const MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_volume(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Cached number of valid vertices
MRC_API int MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_numVerts(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Voxel size as scalar
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_voxelSize(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Transformation mesh to volume
// All points are in voxels volume space, unless otherwise is implied
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_xf_0(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_xf_1(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this, const MR_Vector3f *pt);
 
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_xfInv_0(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_xfInv_1(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this, const MR_Vector3f *pt);
 
// Vertex position
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_point(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_VertId v);
 
// Volume value
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_getValue(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this, const MR_Vector3f *pos);
 
// Get offset vector (mesh normal for a vertex with `voxelSize` length)
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_getOffsetVector(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_VertId v);
 
// Get a pseudo-index for a zero-based point index in a zero-centered row of `count` points
// Pseudo-index is a signed number; for whole index, is is whole or half-whole
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_pseudoIndex_float(float index, int count);
 
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_pseudoIndex_int(int index, int count);
 
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_indexFromPseudoIndex(float pseudoIndex, int count);
 
// Get row of points with `offset` stride
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_getPoints(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_std_vector_MR_Vector3f *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get volume values for a row of points
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_getValues(const MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_std_vector_float *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get derivatives from result of `getValues`
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_getDerivatives(MR_std_vector_float *result, const MR_std_vector_float *values);
 
MRC_API MR_PolynomialWrapper_float *MR_MeshOnVoxelsT_MR_Mesh_MR_SimpleVolumeMinMax_getBestPolynomial(const MR_std_vector_float *values, MR_uint64_t degree);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_ConstructFromAnother(MR_PassBy other_pass_by, MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *other);
 
MRC_API const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_OffsetPtr(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_OffsetMutablePtr(MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_Construct(const MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_SimpleVolumeMinMax *volume, const MR_AffineXf3f *volumeXf);
 
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_Destroy(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_DestroyArray(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Access to base data
MRC_API const MR_Mesh *MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_mesh(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API const MR_SimpleVolumeMinMax *MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_volume(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Cached number of valid vertices
MRC_API int MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_numVerts(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Voxel size as scalar
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_voxelSize(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
// Transformation mesh to volume
// All points are in voxels volume space, unless otherwise is implied
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_xf_0(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_xf_1(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this, const MR_Vector3f *pt);
 
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_xfInv_0(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_xfInv_1(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this, const MR_Vector3f *pt);
 
// Vertex position
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_point(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_VertId v);
 
// Volume value
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_getValue(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this, const MR_Vector3f *pos);
 
// Get offset vector (mesh normal for a vertex with `voxelSize` length)
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_getOffsetVector(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_VertId v);
 
// Get a pseudo-index for a zero-based point index in a zero-centered row of `count` points
// Pseudo-index is a signed number; for whole index, is is whole or half-whole
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_pseudoIndex_float(float index, int count);
 
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_pseudoIndex_int(int index, int count);
 
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_indexFromPseudoIndex(float pseudoIndex, int count);
 
// Get row of points with `offset` stride
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_getPoints(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_std_vector_MR_Vector3f *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get volume values for a row of points
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_getValues(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax *_this, MR_std_vector_float *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get derivatives from result of `getValues`
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_getDerivatives(MR_std_vector_float *result, const MR_std_vector_float *values);
 
MRC_API MR_PolynomialWrapper_float *MR_MeshOnVoxelsT_const_MR_Mesh_MR_SimpleVolumeMinMax_getBestPolynomial(const MR_std_vector_float *values, MR_uint64_t degree);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_ConstructFromAnother(MR_PassBy other_pass_by, MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *other);
 
MRC_API const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_OffsetPtr(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_OffsetMutablePtr(MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_Construct(MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_FunctionVolume *volume, const MR_AffineXf3f *volumeXf);
 
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_Destroy(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_DestroyArray(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
// Access to base data
MRC_API MR_Mesh *MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_mesh(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API const MR_FunctionVolume *MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_volume(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
// Cached number of valid vertices
MRC_API int MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_numVerts(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
// Voxel size as scalar
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_voxelSize(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
// Transformation mesh to volume
// All points are in voxels volume space, unless otherwise is implied
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_xf_0(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_xf_1(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this, const MR_Vector3f *pt);
 
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_xfInv_0(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_xfInv_1(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this, const MR_Vector3f *pt);
 
// Vertex position
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_point(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this, MR_VertId v);
 
// Volume value
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_getValue(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this, const MR_Vector3f *pos);
 
// Get offset vector (mesh normal for a vertex with `voxelSize` length)
MRC_API MR_Vector3f MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_getOffsetVector(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this, MR_VertId v);
 
// Get a pseudo-index for a zero-based point index in a zero-centered row of `count` points
// Pseudo-index is a signed number; for whole index, is is whole or half-whole
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_pseudoIndex_float(float index, int count);
 
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_pseudoIndex_int(int index, int count);
 
MRC_API float MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_indexFromPseudoIndex(float pseudoIndex, int count);
 
// Get row of points with `offset` stride
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_getPoints(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this, MR_std_vector_MR_Vector3f *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get volume values for a row of points
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_getValues(const MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume *_this, MR_std_vector_float *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get derivatives from result of `getValues`
MRC_API void MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_getDerivatives(MR_std_vector_float *result, const MR_std_vector_float *values);
 
MRC_API MR_PolynomialWrapper_float *MR_MeshOnVoxelsT_MR_Mesh_MR_FunctionVolume_getBestPolynomial(const MR_std_vector_float *values, MR_uint64_t degree);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_ConstructFromAnother(MR_PassBy other_pass_by, MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *other);
 
MRC_API const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_OffsetPtr(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_OffsetMutablePtr(MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *ptr, ptrdiff_t i);
 
MRC_API MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_Construct(const MR_Mesh *mesh, const MR_AffineXf3f *meshXf, const MR_FunctionVolume *volume, const MR_AffineXf3f *volumeXf);
 
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_Destroy(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_DestroyArray(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
// Access to base data
MRC_API const MR_Mesh *MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_mesh(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API const MR_FunctionVolume *MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_volume(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
// Cached number of valid vertices
MRC_API int MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_numVerts(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
// Voxel size as scalar
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_voxelSize(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
// Transformation mesh to volume
// All points are in voxels volume space, unless otherwise is implied
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_xf_0(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_xf_1(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this, const MR_Vector3f *pt);
 
MRC_API MR_AffineXf3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_xfInv_0(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this);
 
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_xfInv_1(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this, const MR_Vector3f *pt);
 
// Vertex position
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_point(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this, MR_VertId v);
 
// Volume value
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_getValue(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this, const MR_Vector3f *pos);
 
// Get offset vector (mesh normal for a vertex with `voxelSize` length)
MRC_API MR_Vector3f MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_getOffsetVector(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this, MR_VertId v);
 
// Get a pseudo-index for a zero-based point index in a zero-centered row of `count` points
// Pseudo-index is a signed number; for whole index, is is whole or half-whole
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_pseudoIndex_float(float index, int count);
 
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_pseudoIndex_int(int index, int count);
 
MRC_API float MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_indexFromPseudoIndex(float pseudoIndex, int count);
 
// Get row of points with `offset` stride
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_getPoints(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this, MR_std_vector_MR_Vector3f *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get volume values for a row of points
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_getValues(const MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume *_this, MR_std_vector_float *result, const MR_Vector3f *pos, const MR_Vector3f *offset);
 
// Get derivatives from result of `getValues`
MRC_API void MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_getDerivatives(MR_std_vector_float *result, const MR_std_vector_float *values);
 
MRC_API MR_PolynomialWrapper_float *MR_MeshOnVoxelsT_const_MR_Mesh_MR_FunctionVolume_getBestPolynomial(const MR_std_vector_float *values, MR_uint64_t degree);
 
#ifdef __cplusplus
} // extern "C"
#endif