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);
 
#if ML_DEPRECATED_SINCE(3,5,0)
MLEXPORT ML_DEPRECATED MLDataType MLPromotedType(MLDataType datatype1, MLDataType datatype2);
#endif
 
 
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);
 
#if ML_DEPRECATED_SINCE(3,5,0)
#define MLPromotedPrecision MLGetPromotedPrecision
 
#if defined(WIN32) && !defined(ML_NO_DEPRECATED_WARNINGS)
#pragma deprecated("MLPromotedPrecision")
#endif
 
#endif
 
 
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);
 
 
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
MLEXPORT size_t      MLSizeOfPhysicalType(MLDataType physicalDataType);
 
MLEXPORT MLDataType  MLGetPhysicalDataType(MLDataType dataType);
 
#if defined(WIN32) && !defined(ML_NO_DEPRECATED_WARNINGS)
#pragma deprecated("MLSizeOfPhysicalType")
#pragma deprecated("MLGetPhysicalDataType")
#endif
 
#endif
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
[[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);
 
#if ML_DEPRECATED_SINCE(3,5,0)
#define MLTypeInfosAtIdx MLGetTypeInfosAtIndex
 
#if defined(WIN32) && !defined(ML_NO_DEPRECATED_WARNINGS)
#pragma deprecated("MLSizeOfRegisteredType")
#pragma deprecated("MLSizeOfPhysicalType")
#pragma deprecated("MLGetPhysicalDataType")
#pragma deprecated("MLTypeInfosAtIdx")
#endif
 
 
#endif
 
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