mlLUTIterator.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_LUTITERATOR_H
#define ML_LUTITERATOR_H
 
 
 
#include "mlLUTSystem.h"
#include "mlLUTBasic.h"
#include "mlLUTData.h"
 
 
 
ML_START_NAMESPACE
 
 
class MLLUT_EXPORT LUTIteratorBase
{
protected:
 
 LUTIteratorBase (LUTVisualType vtFrom, LUTVisualType vtTo, int width, int row, int layer);
 
 
public:
 
  virtual ~LUTIteratorBase () {}
 
 
  enum
  {
    L = 0,              
    A_LA = 1,           
    R = 0,              
    G = 1,              
    B = 2,              
    A_RGBA = 3,         
    MAX_CHANNELS = 4,   
  };
 
 
  bool isValid (void) const { return _valid; }
 
  LUTVisualType getSourceType (void) const { return _vtFrom; }
 
  LUTVisualType getTargetType (void) const { return _vtTo; }
 
  bool alphaNeedsInit (void) const { return _initAlpha; }
 
  int getWidth (void) const { return _width; }
 
  inline int operator () (void) const { return _index; }
 
  int getRow (void) const { return _row; }
 
  int getLayer (void) const { return _layer; }
 
  inline bool atEnd (void) const { return _index >= _width; }
 
  inline int getNumChannels (void) const { return LUTNumberOfChannels(_vtFrom); }
 
 
protected:
 
  bool _valid;
 
  LUTVisualType _vtFrom;
 
  LUTVisualType _vtTo;
 
  enum ConvMethod { CONV_NONE = 0, CONV_L_TO_RGB, CONV_RGB_TO_L } _convMethodId;
 
  int _incMethodId;
 
  bool _initAlpha;
 
  int _width;
 
  int _index;
 
  int _row, _layer;
 
};
 
 
 
template <typename T>
class LUTIterator : public LUTIteratorBase
{
public:
 
  LUTIterator (LUTVisualType visualType, LUTData<T> &lutData);
 
  LUTIterator (LUTVisualType visualType, LUTData<T> &lutData, int row);
 
  LUTIterator (LUTVisualType visualType, LUTData<T> &lutData, int row, int layer);
 
 
  ~LUTIterator () override { clear(); }
 
 
  inline void operator ++ (void) { ++_index; (this->*_inc)(); }
 
 
  T **chn;
 
 
protected:
 
  void init (LUTData<T> &lutData);
 
  void clear (void);
 
  void inc1 (void) { chn[0] += _dpLut; }
  void inc2 (void) { chn[0] += _dpLut; chn[1] += _dpLut; }
  void inc3 (void) { chn[0] += _dpLut; chn[1] += _dpLut; chn[2] += _dpLut; }
  void inc4 (void) { chn[0] += _dpLut; chn[1] += _dpLut; chn[2] += _dpLut; chn[3] += _dpLut; }
  void inc5 (void) { chn[0] += _dpLut; chn[3] += _dpLut; }
 
  void convertLtoRGB (void) { chn[L][2] = chn[L][1] = chn[L][0]; }
 
  void convertRGBtoL (void)
  { *chn[L] = LUTCastFromDouble<T>(LUTConvertRGBtoL(static_cast<double>(*chn[R]),
                                                    static_cast<double>(*chn[G]),
                                                    static_cast<double>(*chn[B]))); }
 
 
  void convertAndInc (void) { (this->*_incConvert)(); (this->*_incPointers)(); }
 
 
  typedef void (LUTIterator<T>::*IncrementFnc) (void);
 
  IncrementFnc _inc, _incConvert, _incPointers;
 
  T *_dummy;
 
  int _dpLut;
 
};
 
 
template <typename T>
LUTIterator<T>::LUTIterator (LUTVisualType visualType, LUTData<T> &lutData)
  : LUTIteratorBase(visualType, lutData.getVisualType(), lutData.getWidth(),
                    lutData.getMinRow(), lutData.getMinLayer())
{ init(lutData); }
 
 
template <typename T>
LUTIterator<T>::LUTIterator (LUTVisualType visualType, LUTData<T> &lutData, int row)
  : LUTIteratorBase(visualType, lutData.getVisualType(), lutData.getWidth(),
                    row, lutData.getMinLayer())
{ init(lutData); }
 
 
template <typename T>
LUTIterator<T>::LUTIterator (LUTVisualType visualType, LUTData<T> &lutData, int row, int layer)
  : LUTIteratorBase(visualType, lutData.getVisualType(), lutData.getWidth(),
                    row, layer)
{ init(lutData); }
 
 
template <typename T>
void LUTIterator<T>::init (LUTData<T> &lutData)
{
  chn = nullptr;
  _inc = nullptr;
  _incConvert = nullptr;
  _incPointers = nullptr;
  _dummy = nullptr;
  _dpLut = lutData.getStride(1);
 
  if (_valid)
  {
    // Allocate dummy channel entries and channel pointers
    try
    {
      _dummy = new T[MAX_CHANNELS];
      chn = new T* [MAX_CHANNELS];
      for (int i = 0; i < MAX_CHANNELS; i++)
        chn[i] = _dummy+i;
    }
    catch (...)
    {
      clear();
    }
 
    // Allocation successful?
    if (chn && _dummy)
    {
      // Set conversion method
      switch (_convMethodId)
      {
        case CONV_NONE: break;
        case CONV_L_TO_RGB: _incConvert = &LUTIterator<T>::convertLtoRGB; break;
        case CONV_RGB_TO_L: _incConvert = &LUTIterator<T>::convertRGBtoL; break;
        default: _valid = false;
      }
      // Set pointer increment method
      switch (_incMethodId)
      {
        case 1: _incPointers = &LUTIterator<T>::inc1; break;
        case 2: _incPointers = &LUTIterator<T>::inc2; break;
        case 3: _incPointers = &LUTIterator<T>::inc3; break;
        case 4: _incPointers = &LUTIterator<T>::inc4; break;
        case 5: _incPointers = &LUTIterator<T>::inc5; break;
        default: _valid = false;
      }
      // Set main increment method
      if (_incConvert)
        _inc = &LUTIterator<T>::convertAndInc;
      else
        _inc = _incPointers;
 
      // Initialize channel pointers
      T *pLut = lutData.getEntriesAt(lutData.getMinIndex(), _row, _layer);
      switch (LUTReducedVisualType(getSourceType()))
      {
        case LUT_L:
          chn[L] = pLut+(_vtTo == LUT_ABGR ? 1 : 0);
          break;
 
        case LUT_RGB:
          switch (lutData.getVisualType())
          {
            case LUT_L:
            case LUT_LA:   chn[R] = pLut; break;
 
            case LUT_RGB:
            case LUT_RGBA: chn[R] = pLut; chn[G] = pLut+1; chn[B] = pLut+2; break;
 
            case LUT_ABGR: ++pLut; // fall through
            case LUT_BGR:  chn[B] = pLut; chn[G] = pLut+1; chn[R] = pLut+2; break;
 
            default: _valid = false;
          }
          break;
 
        default: _valid = false;
      }
 
      // Alpha channel pointer
      if (_valid)
      {
        // Index at which alpha channel is stored in LUT data object
        int destAlpha = LUTAlphaChannelIndex(getTargetType());
        if (destAlpha >= 0)
        {
          // Index at which source expects alpha channel pointer
          int srcAlpha = LUTNumberOfChannels(LUTReducedVisualType(getSourceType()));
          chn[srcAlpha] = lutData.getEntriesAt(lutData.getMinIndex(), _row, _layer)+destAlpha;
        }
      }
    }
  }
}
 
 
template <typename T>
void LUTIterator<T>::clear (void)
{
  if (chn)
  {
    delete[] chn;
    chn = nullptr;
  }
  if (_dummy)
  {
    delete[] _dummy;
    _dummy = nullptr;
  }
}
 
 
 
ML_END_NAMESPACE
 
 
#endif
// __mlLUTIterator_H