CortidQCT.h

Go to the documentation of this file.

#ifndef CORTIDQCT_C_BINDINGS_CORTIDQCT_H__
#  define CORTIDQCT_C_BINDINGS_CORTIDQCT_H__

#  ifdef __cplusplus
extern "C" {

#    define CQCT_EXTERN extern "C"
#  else
#    define CQCT_EXTERN
#  endif

#  include <stddef.h>

// MARK: -
// MARK: Object Type / Generic Functions

typedef void *Id;

CQCT_EXTERN Id CQCT_retain(Id obj);

CQCT_EXTERN void CQCT_release(Id obj);

CQCT_EXTERN Id CQCT_autorelease(Id obj);

CQCT_EXTERN void CQCT_autoreleasePoolPush();

CQCT_EXTERN void CQCT_autoreleasePoolPop();


// MARK: -
// MARK: Error Type
enum CQCT_ErrorId {
  CQCT_ErrorId_Unknown,
  CQCT_ErrorId_InvalidArgument,
  CQCT_ErrorId_OutOfRange
};

struct CQCT_Error_t;
typedef struct CQCT_Error_t *CQCT_Error;

CQCT_EXTERN CQCT_Error CQCT_createError(enum CQCT_ErrorId id,
                                        const char *message);

CQCT_EXTERN enum CQCT_ErrorId CQCT_errorType(CQCT_Error error);

CQCT_EXTERN const char *CQCT_errorMessage(CQCT_Error error);


// MARK: -
// MARK: VoxelVolume Type
typedef struct {
  size_t width, heigth, depth;
} CQCT_VoxelVolumeSize;

typedef struct {
  float width, heigth, depth;
} CQCT_VoxelVolumeVoxelSize;

struct CQCT_VoxelVolume_t;
typedef struct CQCT_VoxelVolume_t *CQCT_VoxelVolume;

CQCT_EXTERN CQCT_VoxelVolume CQCT_createVoxelVolume();

CQCT_EXTERN int CQCT_voxelVolumeLoadFromFile(CQCT_VoxelVolume volume,
                                             const char *filename,
                                             CQCT_Error *error);

CQCT_EXTERN CQCT_VoxelVolumeSize CQCT_voxelVolumeSize(CQCT_VoxelVolume volume);

CQCT_EXTERN CQCT_VoxelVolumeVoxelSize
CQCT_voxelVolumeVoxelSize(CQCT_VoxelVolume volume);

CQCT_EXTERN size_t CQCT_voxelVolumeCopyVoxels(CQCT_VoxelVolume volume,
                                              float **buffer);


struct CQCT_ColorToLabelMap_t;
typedef struct CQCT_ColorToLabelMap_t *CQCT_ColorToLabelMap;


// MARK: -
// MARK: Mesh Type
struct CQCT_Mesh_t;
typedef struct CQCT_Mesh_t *CQCT_Mesh;

struct CQCT_BarycentricPoint_t {
  float u;                 
  float v;                 
  ptrdiff_t triangleIndex; 
};
typedef struct CQCT_BarycentricPoint_t CQCT_BarycentricPoint;

struct CQCT_Ray_t {
  float x0, y0, z0;
  float dx, dy, dz;
};
typedef struct CQCT_Ray_t CQCT_Ray;

struct CQCT_RayMeshIntersection {
  CQCT_BarycentricPoint position;
  float t;
  unsigned int : 4 * 8;
};
typedef struct CQCT_RayMeshIntersection CQCT_RayMeshIntersection;

CQCT_EXTERN CQCT_Mesh CQCT_createMesh();

CQCT_EXTERN CQCT_Mesh CQCT_createMeshAndAllocateMemory(size_t nVertices,
                                                       size_t nTriangles,
                                                       CQCT_Error *error);

CQCT_EXTERN CQCT_Mesh CQCT_meshFromFile(const char *filename,
                                        CQCT_Error *error);

CQCT_EXTERN CQCT_Mesh CQCT_meshFromFileWithCustomMapping(
    const char *filename, CQCT_ColorToLabelMap map, CQCT_Error *error);

CQCT_EXTERN CQCT_Mesh CQCT_meshAndLabelsFromFile(const char *meshFilename,
                                                 const char *labelFilename,
                                                 CQCT_Error *error);

CQCT_EXTERN int CQCT_loadMesh(CQCT_Mesh mesh, const char *filename,
                              CQCT_Error *error);

CQCT_EXTERN int CQCT_loadMeshWithCustomMapping(CQCT_Mesh mesh,
                                               const char *filename,
                                               CQCT_ColorToLabelMap map,
                                               CQCT_Error *error);

CQCT_EXTERN int CQCT_loadMeshAndLabels(CQCT_Mesh mesh, const char *meshFilename,
                                       const char *labelFilename,
                                       CQCT_Error *error);

CQCT_EXTERN int CQCT_meshAndLabelsWriteToFile(CQCT_Mesh mesh,
                                              const char *meshFilename,
                                              const char *labelsFilename,
                                              CQCT_Error *error);

CQCT_EXTERN size_t CQCT_meshVertexCount(CQCT_Mesh mesh);

CQCT_EXTERN size_t CQCT_meshTriangleCount(CQCT_Mesh mesh);

CQCT_EXTERN size_t CQCT_meshCopyVertices(CQCT_Mesh mesh, float **bufferPtr);

CQCT_EXTERN void CQCT_meshSetVertices(CQCT_Mesh mesh, float const *buffer);

CQCT_EXTERN size_t CQCT_meshCopyVertexNormals(CQCT_Mesh mesh,
                                              float **bufferPtr);

CQCT_EXTERN void CQCT_meshSetVertexNormals(CQCT_Mesh mesh, float const *buffer);

CQCT_EXTERN size_t CQCT_meshCopyTriangles(CQCT_Mesh mesh,
                                          ptrdiff_t **bufferPtr);

CQCT_EXTERN void CQCT_meshSetTriangles(CQCT_Mesh mesh, ptrdiff_t const *buffer);

CQCT_EXTERN size_t CQCT_meshCopyLabels(CQCT_Mesh mesh,
                                       unsigned int **bufferPtr);

CQCT_EXTERN void CQCT_meshSetLabels(CQCT_Mesh mesh, unsigned int const *buffer);

CQCT_EXTERN int CQCT_meshBarycentricToCartesian(
    CQCT_Mesh mesh, CQCT_BarycentricPoint const *barycentricPtr, size_t nPoints,
    float **bufferPtr, CQCT_Error *error);

CQCT_EXTERN int CQCT_meshBarycentricInterpolation(
    CQCT_Mesh mesh, CQCT_BarycentricPoint const *barycentricPtr, size_t nPoints,
    float const *attributePtr, size_t attributeDimensions, float **bufferPtr,
    CQCT_Error *error);

CQCT_EXTERN size_t
CQCT_meshRayIntersections(CQCT_Mesh mesh, CQCT_Ray *raysPtr, size_t nRays,
                          CQCT_RayMeshIntersection **intersectionsOutPtr);

CQCT_EXTERN void CQCT_meshUpsample(CQCT_Mesh mesh, size_t nTimes);

CQCT_EXTERN void CQCT_meshUpdatePerVertexNormals(CQCT_Mesh mesh);


// MARK: -
// MARK: ColorToLabelMap Type

CQCT_EXTERN CQCT_ColorToLabelMap CQCT_createColorToLabelMap();

CQCT_EXTERN int CQCT_colorToLabelMapLoadFromFile(CQCT_ColorToLabelMap map,
                                                 const char *filename,
                                                 CQCT_Error *error);

CQCT_EXTERN size_t CQCT_colorToLabelMapEntryCount(CQCT_ColorToLabelMap map);

CQCT_EXTERN size_t CQCT_colorToLabelMapCopyEntries(CQCT_ColorToLabelMap map,
                                                   unsigned int **bufferPtr);

CQCT_EXTERN void CQCT_colorToLabelMapSetEntries(CQCT_ColorToLabelMap map,
                                                size_t count,
                                                const unsigned int *entries);


// MARK: -
// MARK: MeshFitterState Type
struct CQCT_MeshFitter_t;
typedef struct CQCT_MeshFitter_t *CQCT_MeshFitter;

struct CQCT_MeshFitterState_t;
typedef struct CQCT_MeshFitterState_t *CQCT_MeshFitterState;

typedef CQCT_MeshFitterState CQCT_MeshFitterResult;

CQCT_EXTERN CQCT_MeshFitterState
CQCT_createMeshFitterState(CQCT_MeshFitter fitter, CQCT_VoxelVolume volume);

CQCT_EXTERN CQCT_Mesh
CQCT_meshFitterResultReferenceMesh(CQCT_MeshFitterResult result);

CQCT_EXTERN CQCT_Mesh CQCT_meshFitterResultMesh(CQCT_MeshFitterResult result);

CQCT_EXTERN size_t CQCT_meshFitterResultCopyDisplacementVector(
    CQCT_MeshFitterResult result, float **buffer);

CQCT_EXTERN void
CQCT_meshFitterResultSetDisplacementVector(CQCT_MeshFitterResult result,
                                           float const *buffer);

CQCT_EXTERN size_t
CQCT_meshFitterResultCopyWeights(CQCT_MeshFitterResult result, float **buffer);

CQCT_EXTERN void CQCT_meshFitterResultSetWeights(CQCT_MeshFitterResult result,
                                                 float const *buffer);

CQCT_EXTERN size_t CQCT_meshFitterResultCopyVertexNormals(
    CQCT_MeshFitterResult result, float **buffer)
    __attribute__((deprecated("Use normals stored in deformedMesh instead.")));

CQCT_EXTERN size_t
CQCT_meshFitterResultVolumeSamplingPositionsCount(CQCT_MeshFitterResult result);

CQCT_EXTERN size_t CQCT_meshFitterResultCopyVolumeSamplingPositions(
    CQCT_MeshFitterResult result, float **buffer);

CQCT_EXTERN size_t CQCT_meshFitterResultCopyVolumeSamples(
    CQCT_MeshFitterResult result, float **buffer);

CQCT_EXTERN float
CQCT_meshFitterResultMinimumDisplacementNorm(CQCT_MeshFitterResult result);

CQCT_EXTERN float
CQCT_meshFitterResultLogLikelihood(CQCT_MeshFitterResult result);

CQCT_EXTERN float
CQCT_meshFitterResultCopyPerVertexLogLikelihood(CQCT_MeshFitterResult result,
                                                float **buffer);

CQCT_EXTERN void
CQCT_meshFitterResultSetLogLikelihood(CQCT_MeshFitterResult result, float ll);

CQCT_EXTERN float
CQCT_meshFitterResultEffectiveSigmaS(CQCT_MeshFitterResult result);

CQCT_EXTERN size_t
CQCT_meshFitterResultIterationCount(CQCT_MeshFitterResult result);

CQCT_EXTERN void
CQCT_meshFitterResultSetIterationCount(CQCT_MeshFitterResult result,
                                       size_t count);

CQCT_EXTERN int CQCT_meshFitterResultHasConverged(CQCT_MeshFitterResult result);

CQCT_EXTERN void
CQCT_meshFitterResultSetHasConverged(CQCT_MeshFitterResult result,
                                     int converged);

CQCT_EXTERN int CQCT_meshFitterResultSuccess(CQCT_MeshFitterResult result);

CQCT_EXTERN void CQCT_meshFitterResultSetSuccess(CQCT_MeshFitterResult result,
                                                 int success);

CQCT_EXTERN size_t
CQCT_meshFitterResultNonDecreasingCount(CQCT_MeshFitterResult result);

CQCT_EXTERN void
CQCT_meshFitterResultSetNonDecreasingCount(CQCT_MeshFitterResult result,
                                           size_t count);

CQCT_EXTERN size_t CQCT_meshFitterStateCopyModelSamplingPositions(
    CQCT_MeshFitterState state, float **buffer);


// MARK: -
// MARK: MeshFitter Type
CQCT_EXTERN CQCT_MeshFitter CQCT_createMeshFitter(const char *filename,
                                                  CQCT_Error *error);

CQCT_EXTERN CQCT_MeshFitterResult CQCT_meshFitterFit(CQCT_MeshFitter meshFitter,
                                                     CQCT_VoxelVolume volume);

CQCT_EXTERN int CQCT_meshFitterFitOneIteration(CQCT_MeshFitter meshFitter,
                                               CQCT_MeshFitterState state,
                                               CQCT_Error *error);

CQCT_EXTERN int CQCT_meshFitterVolumeSamplingStep(CQCT_MeshFitter meshFitter,
                                                  CQCT_MeshFitterState state,
                                                  CQCT_Error *error);

CQCT_EXTERN int CQCT_meshFitterOptimalDisplacementStep(
    CQCT_MeshFitter meshFitter, CQCT_MeshFitterState state, CQCT_Error *error);

CQCT_EXTERN int CQCT_meshFitterOptimalDeformationStep(
    CQCT_MeshFitter meshFitter, CQCT_MeshFitterState state, CQCT_Error *error);

CQCT_EXTERN int CQCT_meshFitterLogLikelihoodStep(CQCT_MeshFitter meshFitter,
                                                 CQCT_MeshFitterState state,
                                                 CQCT_Error *error);

CQCT_EXTERN int CQCT_meshFitterConvergenceTestStep(CQCT_MeshFitter meshFitter,
                                                   CQCT_MeshFitterState state,
                                                   CQCT_Error *error);


#  ifdef __cplusplus
}
#  endif

#endif