mlLUTData.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_LUTDATA_H
#define ML_LUTDATA_H
 

 
#include "mlLUTSystem.h"
#include "mlLUTBasic.h"
 
 
// ML includes
#include "mlDataTypes.h"
 
 
 
ML_START_NAMESPACE
 
class MLLUT_EXPORT LUTDataId
{
public:
  LUTDataId() {
    reset();
  }
 
  void reset() {
    _id = 0;
    _minOriginalRange = 0;
    _maxOriginalRange = 0;
  }
 
  void update(unsigned int id, double minOrig, double maxOrig);
 
  bool operator==(const LUTDataId& other) const;
  bool operator!=(const LUTDataId& other) const;
 
  friend class LUTDataBase;
 
private:
  unsigned int _id;
  double _minOriginalRange;
  double _maxOriginalRange;
};

class MLLUT_EXPORT LUTDataBase
{
protected:

  LUTDataBase (MLDataType dataType);

  MLErrorCode init (LUTVisualType visualType, int minIndex, int maxIndex,
                    int minRow, int maxRow, int minLayer, int maxLayer);

  MLErrorCode initShared1D (LUTVisualType visualType, int minIndex, int maxIndex, int row, int layer,
                            LUTDataBase *srcLutData, int srcIndex, int srcRow, int srcLayer);

  MLErrorCode initShared2D (LUTVisualType visualType, int minRow, int maxRow, int layer,
                            LUTDataBase *srcLutData, int srcRow, int srcLayer);
 
 
public:
  virtual ~LUTDataBase();

  void clear();
 

  bool isInitialized (void) const { return _data != nullptr; }

  bool ownsData (void) const { return _ownsData; }

  MLDataType getDataType (void) const { return _dataType; }

  int getEntrySize (void) const { return _entrySize; }

  LUTVisualType getVisualType (void) const { return _visualType; }

  int getNumChannels (void) const { return _numChannels; }

  LUTDimensionality getDimensionality (void) const { return _dimensionality; }

  int getMinIndex (void) const { return _minIndex; }

  int getMaxIndex (void) const { return _maxIndex; }

  int getWidth (void) const { return _maxIndex-_minIndex+1; }

  int getMinRow (void) const { return _minRow; }

  int getMaxRow (void) const { return _maxRow; }

  int getHeight (void) const { return _maxRow-_minRow+1; }

  int getMinLayer (void) const { return _minLayer; }

  int getMaxLayer (void) const { return _maxLayer; }

  int getDepth (void) const { return _maxLayer-_minLayer+1; }

  int getLength (void) const { return _dataLength; }

  int getStride (int dim) const;

  int getDataSize (void) const { return _dataLength*_entrySize; }

  bool isInRange (int index, int row = 0, int layer = 0) const;

  unsigned int getId (void) const { return _lutId._id; }

  void setId (unsigned int id) { _lutId._id = id; }

  void setId (unsigned int id, double minIndex, double maxIndex) { _lutId.update(id, minIndex, maxIndex); }

  const LUTDataId& getFullId() const { return _lutId; }

  void setFullId(const LUTDataId& id) { _lutId = id; }
 
protected:

  void reset (void);

  void clearData (void);

  bool initData (void);
 

  MLDataType _dataType;

  int _entrySize;

  int _dataLength;

  void *_data;

  bool _ownsData;
 

  LUTVisualType _visualType;

  int _numChannels;

  LUTDimensionality _dimensionality;

  int _minIndex, _maxIndex;

  int _minRow, _maxRow;

  int _minLayer, _maxLayer;

  int _strides[3];

  int _entryOffset;
 

  LUTDataId _lutId;
 
};
 
 

template <typename T>
class LUTData : public LUTDataBase
{
public:

  LUTData():LUTDataBase(getType(reinterpret_cast<T*>(NULL))),_maxEntry(0) {};

  MLDataType getType(MLuint8*) { return MLuint8Type; }
  MLDataType getType(MLint8*) { return MLint8Type; }
  MLDataType getType(MLuint16*) { return MLuint16Type; }
  MLDataType getType(MLint16*) { return MLint16Type; }
  MLDataType getType(MLuint32*) { return MLuint32Type; }
  MLDataType getType(MLint32*) { return MLint32Type; }
  MLDataType getType(MLint64*) { return MLint64Type; }
  MLDataType getType(MLuint64*) { return MLuint64Type; }
  MLDataType getType(float*) { return MLfloatType; }
  MLDataType getType(double*) { return MLdoubleType; }
  MLDataType getType(MLldouble*) { return MLldoubleType; }

  MLErrorCode init (LUTVisualType visualType, int minIndex, int maxIndex, T maxEntry)
  { return init(visualType, minIndex, maxIndex, 0, 0, 0, 0, maxEntry); }

  MLErrorCode init (LUTVisualType visualType, int minIndex, int maxIndex,
                    int minRow, int maxRow, T maxEntry)
  { return init(visualType, minIndex, maxIndex, minRow, maxRow, 0, 0, maxEntry); }

  MLErrorCode init (LUTVisualType visualType, int minIndex, int maxIndex,
                    int minRow, int maxRow, int minLayer, int maxLayer, T maxEntry);
 

  MLErrorCode initShared1D (LUTVisualType visualType, int minIndex, int maxIndex, int row, int layer,
                            LUTData<T> *srcLutData, int srcIndex, int srcRow, int srcLayer);

  MLErrorCode initShared2D (LUTVisualType visualType, int minRow, int maxRow, int layer,
                            LUTData<T> *srcLutData, int srcRow, int srcLayer);
 

  T getMaxEntry (void) const { return _maxEntry; }
 

  T *getData (void) { return reinterpret_cast<T*>(_data); }

  const T *getData (void) const { return reinterpret_cast<const T*>(_data); }

  T *getEntriesAt (int index, int row, int layer)
  { return getData()+(index*_strides[0]+row*_strides[1]+layer*_strides[2]-_entryOffset); }

  const T *getEntriesAt (int index, int row, int layer) const
  { return getData()+(index*_strides[0]+row*_strides[1]+layer*_strides[2]-_entryOffset); }

  T *getEntriesAt (int index, int row)
  { return getEntriesAt(index, row, getMinLayer()); }

  const T *getEntriesAt (int index, int row) const
  { return getEntriesAt(index, row, getMinLayer()); }

  T *getEntriesAt (int index)
  { return getEntriesAt(index, getMinRow(), getMinLayer()); }

  const T *getEntriesAt (int index) const
  { return getEntriesAt(index, getMinRow(), getMinLayer()); }
 

  virtual LUTData<T> *clone (void) const;
 
 
protected:

  T _maxEntry;
 
};
 

template <typename T>
MLErrorCode LUTData<T>::init (LUTVisualType visualType, int minIndex, int maxIndex,
                              int minRow, int maxRow, int minLayer, int maxLayer, T maxEntry)
{
  MLErrorCode result = maxEntry >= 0 ? ML_RESULT_OK : ML_BAD_PARAMETER;
 
  if (result == ML_RESULT_OK) {
    result = LUTDataBase::init(visualType, minIndex, maxIndex, minRow, maxRow, minLayer, maxLayer);
  }
  if (result == ML_RESULT_OK) {
    _maxEntry = maxEntry;
  }
 
  return result;
}
 

template <typename T>
MLErrorCode LUTData<T>::initShared1D (LUTVisualType visualType, int minIndex, int maxIndex, int row, int layer,
                                      LUTData<T> *srcLutData, int srcIndex, int srcRow, int srcLayer)
{
  MLErrorCode result =
    LUTDataBase::initShared1D(visualType, minIndex, maxIndex, row, layer, srcLutData, srcIndex, srcRow, srcLayer);
 
  if (result == ML_RESULT_OK) {
    _maxEntry = srcLutData->getMaxEntry();
  }
 
  return result;
}
 

template <typename T>
MLErrorCode LUTData<T>::initShared2D (LUTVisualType visualType, int minRow, int maxRow, int layer,
                                      LUTData<T> *srcLutData, int srcRow, int srcLayer)
{
  MLErrorCode result =
    LUTDataBase::initShared2D(visualType, minRow, maxRow, layer, srcLutData, srcRow, srcLayer);
 
  if (result == ML_RESULT_OK) {
    _maxEntry = srcLutData->getMaxEntry();
  }
 
  return result;
}
 

template <typename T>
LUTData<T> *LUTData<T>::clone (void) const
{
  LUTData<T> *newLutData = new LUTData<T>;
 
  if (newLutData) {
    if (newLutData->init(_visualType, _minIndex, _maxIndex, _minRow, _maxRow,
                         _minLayer, _maxLayer, _maxEntry) != ML_RESULT_OK) {
      delete newLutData;
      newLutData = nullptr;
    }
  }
 
  return newLutData;
}
 
 
ML_END_NAMESPACE
 
 
 
#endif
//  __mlLUTData_H