mlAPI.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
 
 
#ifdef WIN32
  #include <ThirdPartyWarningsDisable.h>
  #include <windows.h>
  #include <ThirdPartyWarningsRestore.h>
#endif
 
// Attention: All includes must be pure C!
 
#ifndef ML_DISABLE_CPP
#define ML_DISABLE_CPP
#endif
 
#include "mlInitSystemML.h"
 
#undef ML_DISABLE_CPP
 
#include "mlUtilsAPI.h"
 
#include "mlVersion.h"
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
#define mlField  void
 
#define mlSensor void
 
#define mlModule void
 
#define mlBase   void
 
#define mlType   void
 
#ifdef WIN32
  typedef HMODULE MLLibraryHandle;
#else
  typedef void*   MLLibraryHandle;
#endif
 
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT MLint32     MLInit(MLint32 majorVersion, MLint32 majorCAPIVersion, MLint32 revCAPI);
 
MLEXPORT MLint32     MLDestroy();
 
MLEXPORT void        MLHostSetProgressCB(void* userData, MLHostProgressCB* callback);
 
MLEXPORT void        MLHostUpdateProgress(const char* info1, const char* info2);
 
MLEXPORT void        MLHostSetBreakCheckCB(void* userData, MLHostBreakCheckCB* callback);
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
[[nodiscard]]
MLEXPORT MLErrorCode MLLoadLibraryWOErrorExt(const char* name, MLLibraryHandle* libHandle);
 
[[nodiscard]]
MLEXPORT MLErrorCode MLLoadLibraryWOError(const char* name);
 
MLEXPORT MLint32     MLLoadLibrary(const char* name);
 
MLEXPORT MLuint32    MLIsCurrentlyUnloadingLibrary();
 
MLEXPORT MLuint32    MLSetIsCurrentlyUnloadingLibrary(MLuint32 enable);
 
[[nodiscard]]
MLEXPORT MLErrorCode MLUnLoadLibrary(const char* name,
                                     MLLibraryHandle libHandle,
                                     char** errStr);
 
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT mlModule*   MLCreateModuleFromName(const char* className);
 
MLEXPORT void        MLDeleteModule(mlModule* module);
 
MLEXPORT MLint32     MLBaseIsDerivedFrom(mlBase* base, const char* superClassName);
 
MLEXPORT const char* MLBaseGetType(mlBase* base);
 
MLEXPORT mlType*     MLBaseGetTypeObject(mlBase* base);
 
MLEXPORT const char* MLBaseGetParentType(mlBase* base);
 
MLEXPORT mlModule*   MLCreateModuleFromType(mlType* type);
 
MLEXPORT mlType*     MLTypeFromName(const char* name);
 
MLEXPORT MLint32     MLTypeIsAbstract(mlType* type);
 
MLEXPORT const char* MLTypeGetName(mlType* type);
 
MLEXPORT const char* MLTypeGetDllName(mlType* type);
 
MLEXPORT const char* MLTypeGetParentName(mlType* type);
 
MLEXPORT mlType*     MLTypeGetParentType(mlType* type);
 
MLEXPORT MLint32     MLTypeIsDerivedFrom(mlType* type, const char* parent);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT mlField*    MLModuleGetField(mlModule* module, const char* name);
 
MLEXPORT size_t      MLModuleGetNumFields(mlModule* module);
 
MLEXPORT mlField*    MLModuleGetIndexedField(mlModule* module, MLint32 n);
 
MLEXPORT void        MLModuleSetFieldValue(mlModule* module, char* fieldName, char* value);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT void        MLBeginLoadFields(mlModule* module);
 
MLEXPORT void        MLEndLoadFields(mlModule* module);
 
MLEXPORT void        MLBeginSaveFields(mlModule* module);
 
MLEXPORT void        MLEndSaveFields(mlModule* module);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT const char* MLFieldGetName(mlField* field);
 
MLEXPORT const char* MLFieldGetType(mlField* field);
 
MLEXPORT void        MLFieldSetValue(mlField* field, const char* value);
 
MLEXPORT size_t      MLFieldGetValueSize(mlField* field);
 
MLEXPORT size_t      MLFieldGetValue(mlField* field, char* value, size_t bufferSize);
 
MLEXPORT void        MLFieldSetFloatValue(mlField* field, MLfloat value);
 
MLEXPORT MLfloat     MLFieldGetFloatValue(mlField* field);
 
MLEXPORT void        MLFieldSetDoubleValue(mlField* field, MLdouble value);
 
MLEXPORT MLdouble    MLFieldGetDoubleValue(mlField* field);
 
MLEXPORT void        MLFieldSetIntValue(mlField* field, MLint32 value);
 
MLEXPORT void        MLFieldSetIntValue64(mlField* field, MLint64 value);
 
MLEXPORT MLint32     MLFieldGetIntValue(mlField* field);
 
MLEXPORT MLint64     MLFieldGetIntValue64(mlField* field);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT int       MLFieldGetEnumValue(mlField* field);
 
MLEXPORT void      MLFieldSetEnumValue(mlField* field, int val);
 
MLEXPORT size_t    MLFieldGetNumEnums(mlField* field);
 
MLEXPORT const char* MLFieldGetEnumName(mlField* field, MLint32 i, int* value);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT MLint32 MLFieldConnectFrom(mlField* inField, mlField* outField);
 
MLEXPORT MLint32 MLImageFieldConnectFromNoNotify(mlField* inField, mlField* outField);
 
MLEXPORT void  MLFieldDisconnect(mlField* inField);
 
MLEXPORT void  MLFieldTouch(mlField* field);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetTile6D(mlField* outField, void** memory,
                                      MLint x,  MLint y,  MLint z,  MLint c,  MLint t,  MLint u,
                                      MLint nx, MLint ny, MLint nz, MLint nc, MLint nt, MLint nu,
                                      MLDataType datatype);
 
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetTile4D(mlField* outField, void** memory,
                                      MLint x,  MLint y,  MLint z,  MLint c,
                                      MLint nx, MLint ny, MLint nz, MLint nc,
                                      MLDataType datatype);
 
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetTile3D(mlField* outField, void** memory,
                                      MLint x,  MLint y,  MLint z,
                                      MLint nx, MLint ny, MLint nz,
                                      MLDataType datatype);
 
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetTile(mlField* outField, void** memory,
                                    MLint x,  MLint y,  MLint z,
                                    MLint nx, MLint ny, MLint nz,
                                    MLDataType datatype);
 
 
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetScaledTile6D(mlField* outField, void** memory,
                                            MLint x,  MLint y,  MLint z,  MLint c,  MLint t,  MLint u,
                                            MLint nx, MLint ny, MLint nz, MLint nc, MLint nt, MLint nu,
                                            MLDataType datatype,
                                            MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax);
 
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetScaledTile4D(mlField* outField, void** memory,
                                            MLint x,  MLint y,  MLint z,  MLint c,
                                            MLint nx, MLint ny, MLint nz, MLint nc,
                                            MLDataType datatype,
                                            MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax);
 
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetScaledTile3D(mlField* outField, void** memory,
                                            MLint x,  MLint y,  MLint z,
                                            MLint nx, MLint ny, MLint nz,
                                            MLDataType datatype,
                                            MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax);
 
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetScaledTile(mlField* outField, void** memory,
                                          MLint x,  MLint y,  MLint z,
                                          MLint nx, MLint ny, MLint nz,
                                          MLDataType datatype,
                                          MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax);
 
MLEXPORT void  MLImageFreeTile(void *data);
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
 
MLEXPORT MLuint64 MLCacheGetCurrentSizeKB();
 
MLEXPORT MLuint64 MLCacheGetMaxSizeKB();
 
MLEXPORT void  MLCacheSetMaxSizeKB(MLuint64 size);
 
MLEXPORT MLErrorCode MLClearPagesAndMemoryImg(mlField* outField);
 
MLEXPORT MLErrorCode MLClearPages(mlField* outField);
 
MLEXPORT MLErrorCode MLClearMemoryImg(mlField* outField);
 
MLEXPORT MLErrorCode MLGetPageMemorySize(mlField* outField, size_t* numBytes);
 
MLEXPORT MLErrorCode MLGetMemoryImgSize(mlField* outField, size_t *numBytes);
 
MLEXPORT void MLClearCache();
 
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
[[nodiscard]]
MLEXPORT MLErrorCode MLGetImageState(mlField* outField);
 
[[nodiscard]]
MLEXPORT const char* MLGetImageStateString(mlField* outField);
 
MLEXPORT MLErrorCode MLImageGetSize6D(mlField* outField, int *x, int *y, int *z, int *c, int *t, int *u);
 
MLEXPORT MLErrorCode MLImageGetPageSize6D(mlField* outField, int *x, int *y, int *z, int *c, int *t, int *u);
 
 
MLEXPORT MLErrorCode MLImageGetSize(mlField* outField, int *x, int *y, int *z, int *c);
 
MLEXPORT MLErrorCode MLImageGetType(mlField* outField, MLDataType* dtype, size_t* dsize);
 
MLEXPORT MLErrorCode MLImageGetVoxelSize(mlField* outField, MLfloat *x, MLfloat *y, MLfloat *z);
 
MLEXPORT MLErrorCode MLImageGetVoxelSizeInDoubles(mlField* outField, MLdouble *x, MLdouble *y, MLdouble *z);
 
[[nodiscard]]
MLEXPORT MLErrorCode MLImageGetFirstImagePropertyExtensionByType(mlField*    outField,
                                                                 const char* imagePropertyTypeClassName,
                                                                 void**      imagePropertyExtension);
 
MLEXPORT MLErrorCode MLImageGetMinValue(mlField* outField, MLdouble* minValue);
 
MLEXPORT MLErrorCode MLImageGetMaxValue(mlField* outField, MLdouble* maxValue);
 
MLEXPORT MLErrorCode MLImageGetVoxelToWorldMatrix(mlField* outField, MLfloat [16]);
 
MLEXPORT MLErrorCode MLImageGetVoxelToWorldMatrixInDoubles(mlField* outField, MLdouble [16]);
 
MLEXPORT MLErrorCode MLImageGetWorldToVoxelMatrix(mlField* outField, MLfloat [16]);
 
MLEXPORT MLErrorCode MLImageGetWorldToVoxelMatrixInDoubles(mlField* outField, MLdouble [16]);
 
MLEXPORT MLErrorCode MLImageMapVoxelToWorld(mlField* outField, MLfloat srcX, MLfloat srcY, MLfloat srcZ,
                                                               MLfloat *dstX, MLfloat *dstY, MLfloat *dstZ);
 
MLEXPORT MLErrorCode MLImageMapVoxelToWorldInDoubles(mlField* outField, MLdouble srcX,  MLdouble srcY,  MLdouble srcZ,
                                                                        MLdouble *dstX, MLdouble *dstY, MLdouble *dstZ);
 
MLEXPORT MLErrorCode MLImageMapWorldToVoxel(mlField* outField, MLfloat srcX, MLfloat srcY, MLfloat srcZ,
                                                               MLfloat *dstX, MLfloat *dstY, MLfloat *dstZ);
 
MLEXPORT MLErrorCode MLImageMapWorldToVoxelInDoubles(mlField* outField, MLdouble srcX,  MLdouble srcY,  MLdouble srcZ,
                                                                        MLdouble *dstX, MLdouble *dstY, MLdouble *dstZ);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
 
MLEXPORT const char* MLBaseFieldGetPersistentState(mlField* baseField);
 
MLEXPORT void  MLBaseFieldSetPersistentState(mlField* baseField, const char* state);
 
MLEXPORT void  MLBaseFieldClearPersistentState(mlField* baseField, char* state);
 
MLEXPORT void* MLBaseFieldGetPtr(mlField* field);
 
MLEXPORT void  MLBaseFieldSetPtr(mlField* baseField, const void *value);
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
 
MLEXPORT void* MLSoNodeFieldGetPtr(mlField* field);
 
MLEXPORT void  MLSoNodeFieldSetPtr(mlField* field, const void* value);
 
 
MLEXPORT void* MLPointerFieldGetPtr(mlField* field);
 
MLEXPORT void  MLPointerFieldSetPtr(mlField* field, const void* value);
 
 
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT mlSensor* MLCreateFieldSensor(void* userData, MLSensorCB* callback);
 
MLEXPORT void  MLDeleteFieldSensor(mlSensor* sensor);
 
MLEXPORT mlField* MLFieldSensorGetField(mlSensor* sensor);
 
MLEXPORT void  MLFieldSensorAttach(mlSensor* sensor, mlField* field);
 
MLEXPORT void  MLFieldSensorDetach(mlSensor* sensor);
 
 
//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
MLEXPORT MLint32       MLAreMessagesSentToCout();
 
MLEXPORT void          MLSendMessagesToCout(MLint32 on);
 
MLEXPORT MLint32       MLAreMessagesSentToCerr();
 
MLEXPORT void          MLSendMessagesToCerr(MLint32 on);
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
MLEXPORT MLErrorCode   MLSetMaxNumThreads(MLuint32 numThreads);
 
MLEXPORT MLuint32      MLGetMaxNumThreads();
 
#ifdef __cplusplus
}
#endif