mlDataTypes.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
**
**************************************************************************************/
 
#ifndef ML_DATA_TYPES_H
#define ML_DATA_TYPES_H

 
#include "mlInitSystemML.h"
 
#include "mlUtilsAPI.h"
 
// Compile with C-Link interface.
#ifdef __cplusplus
extern "C" {
#endif
 
#include "mlTypeDefs.h"
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
[[nodiscard]]
MLEXPORT MLint32             MLAreTypesInitialized();

MLEXPORT MLint32             MLInitializeTypes();

MLEXPORT void                MLDestroyTypes();
 
 
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
MLEXPORT const char * const *       MLDataTypeNames();

MLEXPORT size_t              MLNumDataTypes();

MLEXPORT const char *        MLNameFromDataType(MLDataType dataType);

MLEXPORT MLDataType          MLDataTypeFromName(const char* const name);

MLEXPORT MLdouble            MLDataTypeMax(MLDataType dataType);

MLEXPORT MLdouble            MLDataTypeMin(MLDataType dataType);

MLEXPORT size_t              MLSizeOf(MLDataType dataType);

MLEXPORT size_t              MLSizeOfRegisteredType(MLDataType dataType);

MLEXPORT MLint32             MLRangeOrder(MLDataType dataType);

MLEXPORT MLint32             MLIsValidType(MLDataType dataType);

MLEXPORT MLint32             MLIsSigned(MLDataType dataType);

MLEXPORT MLint32             MLIsIntType(MLDataType dataType);

MLEXPORT MLint32             MLIsFloatType(MLDataType dataType);

MLEXPORT MLint32             MLIsStandardType(MLDataType dataType);
MLEXPORT MLint32             MLIsScalarType(MLDataType dataType);

MLEXPORT MLint32             MLIsDefaultExtendedType(MLDataType dataType);

MLEXPORT MLTypeGroup         MLGetTypeGroup(MLDataType dataType);

MLEXPORT MLDataType MLGetPromotedTypeWithRange(const MLDataType* inputTypes, size_t numTypes,
                                               double rangeMin, double rangeMax);

MLEXPORT MLDataType MLGetPromotedTypeWithRange1Input (MLDataType inputType1,
                                                      double rangeMin, double rangeMax);

MLEXPORT MLDataType MLGetPromotedTypeWithRange2Inputs(MLDataType inputType1, MLDataType inputType2,
                                                      double rangeMin, double rangeMax);

MLEXPORT MLDataType MLGetPromotedTypeWithRange3Inputs(MLDataType inputType1, MLDataType inputType2, MLDataType inputType3,
                                                      double rangeMin, double rangeMax);

MLEXPORT MLint32             MLHolds(MLDataType datatype1, MLDataType datatype2);

MLEXPORT MLDataType          MLGetPromotedType(MLDataType datatype1, MLDataType datatype2);
 

MLEXPORT MLDataType MLGetIntegerDataTypeForRange(double rangeMin, double rangeMax);

MLEXPORT MLDataType           MLGetDataTypeForRange(MLdouble *min,
                                                    MLdouble *max,
                                                    MLint32 preferUnsigned);

MLEXPORT MLDataType           MLGetDataTypeForUncorrectedRange(MLdouble min,
                                                               MLdouble max,
                                                               MLint32 preferUnsigned);

MLEXPORT MLDataType           MLGetRangeAndPrecisionEquivalent(MLDataType dataType);

MLEXPORT MLDataType           MLGetPromotedPrecision(MLDataType datatype1, MLDataType datatype2);

MLEXPORT MLErrorCode          MLClampIntervalToDataTypeRange(double intervalMin, double intervalMax, MLDataType dataType, double* resultIntervalMin, double* resultIntervalMax);

MLEXPORT size_t               MLTypeGetNumComponents(MLDataType dataType);

MLEXPORT const char *         MLTypeGetStructInfoString(MLDataType dataType);

MLEXPORT MLDataType           MLTypeGetBestScalarTypeForTypeComponentChars(const char *charCodes,
                                                                           int suppressML64BitInts,
                                                                           int suppressMLldouble);
MLEXPORT MLDataType           MLTypeGetBestScalarTypeForTypeComponents(MLDataType dataType,
                                                                       int suppressML64BitInts,
                                                                       int suppressMLldouble);
 
 
 
 
 
//---------------------------------------------------------------------------------------------
//
//
//                                REGISTERED TYPE SUPPORT
//
//
//---------------------------------------------------------------------------------------------
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
extern MLEXPORT const MLTypePropertyBits MLTypeHasNoProperties          ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasGetStringValue        ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasSetStringValue        ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeIsDefaultType            ; 
extern MLEXPORT const MLTypePropertyBits MLTypeIsSignedType             ; 
extern MLEXPORT const MLTypePropertyBits MLTypeIsFloatingPointType      ; 
extern MLEXPORT const MLTypePropertyBits MLTypeIsIntegerType            ; 
extern MLEXPORT const MLTypePropertyBits MLTypeIsStandardType           ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasSetToMinimum          ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasSetToMaximum          ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasSetToDefault          ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCopy                  ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCastToBool            ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCastToInt             ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCastToDouble          ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCastToOtherType       ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCastFromInt           ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCastFromDouble        ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasCastFromOtherType     ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasNegate                ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasNormalize             ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasIsEqualToType         ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasMultWithInt           ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasMultWithDouble        ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasMultWithType          ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasMultWithOtherType     ; 
 
extern MLEXPORT const MLTypePropertyBits MLTypeHasPlusInt               ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasPlusDouble            ; 
extern MLEXPORT const MLTypePropertyBits MLTypeHasPlusType              ; 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
extern MLEXPORT const MLTypePropertyBits MLTypeScalarType               ; 
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
MLEXPORT MLint32        MLTypePropBitsTest(MLTypePropertyBits propertyBits, MLTypePropertyBits mask);

MLEXPORT MLTypePropertyBits MLTypePropBitsAnd(MLTypePropertyBits propertyBits, MLTypePropertyBits mask);

MLEXPORT MLTypePropertyBits MLTypePropBitsOr(MLTypePropertyBits propertyBits, MLTypePropertyBits mask);

MLEXPORT MLTypePropertyBits MLTypePropBitsXor(MLTypePropertyBits propertyBits, MLTypePropertyBits mask);
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
[[nodiscard]]
MLEXPORT MLint32      MLRegisterTypeInfos(MLTypeInfos *infos);

MLEXPORT MLint32      MLRegisterStaticTypeInfos(MLTypeInfos *infos, MLDataType dt);

MLEXPORT MLint32      MLIsRegisteredTypeInfos(const MLTypeInfos *infos);

MLEXPORT size_t       MLGetNumRegisteredTypeInfos();

MLEXPORT MLTypeInfos* MLGetTypeInfosAtIndex(size_t index);

MLEXPORT MLTypeInfos* MLGetTypeInfosForDataType(MLDataType dataType);
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------
MLEXPORT MLint32 MLTypeInfosInit(MLTypeInfos       *infos,
                                 size_t             typeSize,
                                 const char        *name,
                                 MLdouble           dblMin,
                                 MLdouble           dblMax,
                                 const MLTypeData  *typeMinPtr,
                                 const MLTypeData  *typeMaxPtr,
                                 const MLTypeData  *typeDefaultPtr,
                                 const char        *typeStructInfo,
                                 MLint32            isScalarType,
                                 MLTypeGroup        typeGroup,
                                 MLDataType         rangeAndPrecisionEquiv,
                                 void             **componentAddresses,
                                 size_t             numGoodCastTos,
                                 const char       **goodCastTos);

[[nodiscard]]
MLEXPORT MLTypeData *MLTypeInfosCreateBuffer(const MLTypeInfos* infos);

MLEXPORT void MLTypeInfosRemoveBuffer(MLTypeData* buffer);

MLEXPORT void MLTypeCorrectPropertyBits(MLTypeInfos* infos);

MLEXPORT void MLTypeSetDefaultFunctionPointers(MLTypeInfos* infos);

MLEXPORT void MLTypeToggleEndianType(const MLTypeInfos *infos,
                                     const MLTypeData *sourceBufferPointer, MLTypeData *targetBufferPointer,
                                     size_t numInstances);

MLEXPORT void MLTypeConvertToLittleEndian(const MLTypeInfos *infos,
                                          const MLTypeData *sourceBufferPointer, MLTypeData *targetBufferPointer,
                                          size_t numInstances);

MLEXPORT void MLTypeConvertToBigEndian(const MLTypeInfos *infos,
                                       const MLTypeData *sourceBufferPointer, MLTypeData *targetBufferPointer,
                                       size_t numInstances);
 
 
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
MLEXPORT const char *MLGetCDataTypeNameForCharCode(char code);

MLEXPORT const char *MLGetMLDataTypeNameForCharCode(char code);

MLEXPORT MLDataType  MLGetMLDataTypeForCharCode(char code);

MLEXPORT MLint32  MLTypeGetComponentProperties(char code,
                                               MLint32 *isSigned,
                                               MLint32 *isIntegerType,
                                               MLint32 *isFloatingPointType,
                                               MLint32 *isLongType);

MLEXPORT size_t   MLTypeComponentSize(char component);

MLEXPORT void     MLTypeSetDoubleComponent(char component, MLdouble value, MLTypeData* targetPointer);

MLEXPORT void     MLTypeSetIntComponent   (char component, MLint value, MLTypeData* targetPointer);

MLEXPORT void     MLTypeSetAllDoubleComponents(const MLTypeInfos* infos, MLdouble value, MLTypeData* targetPointer);

MLEXPORT void     MLTypeSetAllIntComponent    (const MLTypeInfos *infos, MLint value, MLTypeData* targetPointer);

MLEXPORT MLdouble MLTypeGetDoubleComponent(char component, const MLTypeData* targetPointer);

MLEXPORT MLint    MLTypeGetIntComponent   (char component, const MLTypeData* targetPointer);

MLEXPORT MLErrorCode MLTypeGetMinMaxRangeOfComponents(const MLTypeInfos *infos,
                                                      const MLTypeData *srcPtr,
                                                      MLdouble *retMin,
                                                      MLdouble *retMax);

 
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
[[nodiscard]]
MLEXPORT MLTypeData *MLAllocateVoxelBuffer(MLDataType dataType, size_t numVoxels, const MLTypeData* voxelDefaultValue);

[[nodiscard]]
MLEXPORT char       *MLGetVoxelValueAsString(const MLTypeData* data, MLDataType dataType, MLErrorCode* errorCode);

[[nodiscard]]
MLEXPORT char       *MLGetVoxelValueAsStringLimited(const MLTypeData* data, MLDataType dataType, MLErrorCode* errorCode, int maxPrecision);

[[nodiscard]]
MLEXPORT char       *MLTypeComponentsToString(const MLTypeInfos* infos, const MLTypeData* data);

[[nodiscard]]
MLEXPORT char       *MLTypeComponentsToStringLimited(const MLTypeInfos* infos, const MLTypeData* data, int maxPrecision);

[[nodiscard]]
MLEXPORT MLint32     MLTypeComponentsFromString(const MLTypeInfos* infos, const char* stringData, const MLTypeData* defaultValue, MLTypeData* data);

[[nodiscard]]
MLEXPORT MLTypeData *MLTypeGetDataValuesFromString(MLDataType dataType, const char* voxelValue, const MLTypeData *defaultValue, size_t numInstances);

MLEXPORT MLint32     MLTypeComponentsFromStream(void *iStr,    void *iStrStream,
                                                void *stdiStr, void *stdiStrStream,
                                                const MLTypeInfos *infos, MLTypeData *data);

MLEXPORT MLdouble    MLGetVoxelValueAsDouble(const void* data, MLDataType dataType, MLErrorCode* errorCode);

MLEXPORT bool        MLTypeCastToBool     (const MLTypeInfos* infos, const MLTypeData* data);

MLEXPORT MLint       MLTypeCastToInt      (const MLTypeInfos* infos, const MLTypeData* data);

MLEXPORT MLdouble    MLTypeCastToDouble   (const MLTypeInfos* infos, const MLTypeData* data);

MLEXPORT void        MLTypeCastFromBool   (const MLTypeInfos* infos, bool boolValue, MLTypeData* data);

MLEXPORT void        MLTypeCastFromInt    (const MLTypeInfos *infos, MLint intValue, MLTypeData* data);

MLEXPORT void        MLTypeCastFromDouble (const MLTypeInfos* infos, MLdouble doubleValue, MLTypeData* data);

MLEXPORT void        MLTypeShiftComponentsLeft(const MLTypeInfos *infos, const MLTypeData* sourceData, MLint shiftLeft, MLTypeData* targetData);
 

MLEXPORT void      MLTypeCastToOtherType(const MLTypeInfos* otherInfos, const MLTypeData* otherData,
                                         const MLTypeInfos* myInfos,    MLTypeData*       myData);

MLEXPORT void      MLTypeCastFromOtherType(const MLTypeInfos* otherInfos, const MLTypeData* otherData,
                                           const MLTypeInfos* myInfos,    MLTypeData*       myData);

MLEXPORT void      MLTypeMultWithOtherType(const MLTypeInfos* myInfos,    const MLTypeData* myData,
                                           const MLTypeInfos* otherInfos, const MLTypeData* otherData,
                                           MLTypeData* targetData);
 
// C-Link interface off.
#ifdef __cplusplus
}
#endif
 
#endif //of __mlDataTypes_H