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

Go to the documentation of this file.

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

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


#ifndef __mlLUTIterator_H
#define __mlLUTIterator_H

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



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);


  virtual ~LUTIterator () { 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((double)(*chn[R]), (double)(*chn[G]), (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 = 0; 
  _inc = 0;
  _incConvert = 0;
  _incPointers = 0;
  _dummy = 0;
  _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 = 0;
  }
  if (_dummy)
  {
    delete[] _dummy;
    _dummy = 0;
  }
}



ML_END_NAMESPACE


#endif
// __mlLUTIterator_H