MeVis/Foundation/Sources/ML/include/mlAPI.h

Go to the documentation of this file.

// **InsertLicense** code
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------

#ifdef WIN32
  #include "mlSystemWarningsDisable.h"
  #include <windows.h>
  #include "mlSystemWarningsRestore.h"
#endif

// Attention: All includes must be pure C!

#ifndef ML_DISABLE_CPP
#define ML_DISABLE_CPP
#endif

#ifndef __mlInitSystemML_H_PURE_C
#include "mlInitSystemML.h"
#endif

#undef ML_DISABLE_CPP

#ifndef __mlUtilsAPI_H_PURE_C
#include "mlUtilsAPI.h"
#endif

#ifndef __mlVersion_H
#include "mlVersion.h"
#endif


//-----------------------------------------------------------------------------------

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

//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
MLEXPORT MLErrorCode MLLoadLibraryWOErrorExt(const char* name, MLLibraryHandle* libHandle) ML_RETURN_VALUE_SHOULD_BE_USED;

MLEXPORT MLErrorCode MLLoadLibraryWOError(const char* name) ML_RETURN_VALUE_SHOULD_BE_USED;

MLEXPORT MLint32     MLLoadLibrary(const char* name);

MLEXPORT MLuint32    MLIsCurrentlyUnloadingLibrary();

MLEXPORT MLuint32    MLSetIsCurrentlyUnloadingLibrary(MLuint32 enable);

MLEXPORT MLErrorCode MLUnLoadLibrary(const char* name,
                                     MLLibraryHandle libHandle,
                                     char** errStr) ML_RETURN_VALUE_SHOULD_BE_USED;




//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
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 mlType*     MLRuntimeGetFirstModuleType();

MLEXPORT mlType*     MLRuntimeGetNextModuleType();

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 MLint32     MLFieldGetValueSize(mlField* field);

MLEXPORT MLint32     MLFieldGetValue(mlField* field, char* value, MLint32 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);



//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
MLEXPORT MLErrorCode MLImageGetTile6D(mlField* outField, void** memory,
                                      int x,  int y,  int z,  int c,  int t,  int u, 
                                      int nx, int ny, int nz, int nc, int nt, int nu, 
                                      MLDataType datatype) ML_RETURN_VALUE_SHOULD_BE_USED;

  
MLEXPORT MLErrorCode MLImageGetTile4D(mlField* outField, void** memory,
                                      int x,  int y,  int z,  int c, 
                                      int nx, int ny, int nz, int nc, 
                                      MLDataType datatype) ML_RETURN_VALUE_SHOULD_BE_USED;
  

MLEXPORT MLErrorCode MLImageGetTile3D(mlField* outField, void** memory,
                                      int x,  int y,  int z, 
                                      int nx, int ny, int nz, 
                                      MLDataType datatype) ML_RETURN_VALUE_SHOULD_BE_USED;
  

MLEXPORT MLErrorCode MLImageGetTile(mlField* outField, void** memory,
                                    int x,  int y,  int z, 
                                    int nx, int ny, int nz, 
                                    MLDataType datatype) ML_RETURN_VALUE_SHOULD_BE_USED;
  


MLEXPORT MLErrorCode MLImageGetScaledTile6D(mlField* outField, void** memory,
                                            int x,  int y,  int z,  int c,  int t,  int u, 
                                            int nx, int ny, int nz, int nc, int nt, int nu, 
                                            MLDataType datatype,
                                            MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax) ML_RETURN_VALUE_SHOULD_BE_USED;


MLEXPORT MLErrorCode MLImageGetScaledTile4D(mlField* outField, void** memory,
                                            int x,  int y,  int z,  int c,  
                                            int nx, int ny, int nz, int nc, 
                                            MLDataType datatype,
                                            MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax) ML_RETURN_VALUE_SHOULD_BE_USED;
 

MLEXPORT MLErrorCode MLImageGetScaledTile3D(mlField* outField, void** memory,
                                            int x,  int y,  int z,  
                                            int nx, int ny, int nz, 
                                            MLDataType datatype,
                                            MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax) ML_RETURN_VALUE_SHOULD_BE_USED;


MLEXPORT MLErrorCode MLImageGetScaledTile(mlField* outField, void** memory,
                                          int x,  int y,  int z,  
                                          int nx, int ny, int nz, 
                                          MLDataType datatype,
                                          MLdouble srcMin, MLdouble srcMax, MLdouble dstMin, MLdouble dstMax) ML_RETURN_VALUE_SHOULD_BE_USED;

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




//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
MLEXPORT MLErrorCode MLGetImageState(mlField* outField) ML_RETURN_VALUE_SHOULD_BE_USED;

MLEXPORT const char* MLGetImageStateString(mlField* outField) ML_RETURN_VALUE_SHOULD_BE_USED;

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 MLImageGetFirstImagePropertyExtensionByType(mlField*    outField,
                                                                 const char* imagePropertyTypeClassName,
                                                                 void**      imagePropertyExtension) ML_RETURN_VALUE_SHOULD_BE_USED;

MLEXPORT MLErrorCode MLImageGetMinValue(mlField* outField, MLdouble* minValue);

MLEXPORT MLErrorCode MLImageGetMaxValue(mlField* outField, MLdouble* maxValue);

MLEXPORT MLErrorCode MLImageGetVoxelToWorldMatrix(mlField* outField, MLfloat [16]);

MLEXPORT MLErrorCode MLImageGetWorldToVoxelMatrix(mlField* outField, MLfloat [16]);

MLEXPORT MLErrorCode MLImageMapVoxelToWorld(mlField* outField, MLfloat srcX, MLfloat srcY, MLfloat srcZ, 
                                            MLfloat *dstX, MLfloat *dstY, MLfloat *dstZ);

MLEXPORT MLErrorCode MLImageMapWorldToVoxel(mlField* outField, MLfloat srcX, MLfloat srcY, MLfloat srcZ, 
                                            MLfloat *dstX, MLfloat *dstY, MLfloat *dstZ);



//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------

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


//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
MLEXPORT MLErrorCode   MLPushState(MLint32 readEnvVars) ML_RETURN_VALUE_SHOULD_BE_USED;

MLEXPORT MLErrorCode   MLPopState();


#ifdef __cplusplus
}
#endif