MeVisLab/Standard/Sources/Shared/MLLUT/mlLUTData.h

Go to the documentation of this file.

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

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


#ifndef __mlLUTData_H
#define __mlLUTData_H

// Local includes
#ifndef __mlLUTSystem_H
#include "mlLUTSystem.h"
#endif
#ifndef __mlLUTBasic_H
#include "mlLUTBasic.h"
#endif


// ML includes
#ifndef __mlDataTypes_H
#include "mlDataTypes.h"
#endif



ML_START_NAMESPACE


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 () { clear(); }

  void clear (void);


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

  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 _id; }

  void setId (unsigned int id) { _id = 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;
  

  unsigned int _id;

};



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

  LUTData():LUTDataBase(getType((T*)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 (T*)_data; }
  
  const T *getData (void) const { return (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 = 0;
    }
  }
  
  return newLutData;
}


ML_END_NAMESPACE



#endif
//  __mlLUTData_H