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

Go to the documentation of this file.

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

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


#ifndef __mlLUTFLinear_H
#define __mlLUTFLinear_H

// Local includes
#ifndef __mlLUTSystem_H
#include "mlLUTSystem.h"
#endif
#ifndef __mlLUTFunction_H
#include "mlLUTFunction.h"
#endif

#include <vector>

ML_START_NAMESPACE

class MLLUT_EXPORT LUTRGBAPoint 
{
public:
  LUTRGBAPoint();
  LUTRGBAPoint(double posArg, double rArg, double gArg, double bArg, double aArg);

  double pos() const { return _v[0]; }
  void setPos(double posArg) { _v[0] = posArg; }

  double r() const { return _v[1]; }
  void setR(double rArg) { _v[1] = rArg; }
  double g() const { return _v[2]; }
  void setG(double gArg) { _v[2] = gArg; }
  double b() const { return _v[3]; }
  void setB(double bArg) { _v[3] = bArg; }
  double a() const { return _v[4]; }
  void setA(double aArg) { _v[4] = aArg; }

  void setL(double lArg) {
    _v[1] = lArg; _v[2] = lArg; _v[3] = lArg;
  }

  double l() const {
    return _v[1];
  }

  void setRGBA(double rArg, double gArg, double bArg, double aArg) {
    _v[1] = rArg;
    _v[2] = gArg;
    _v[3] = bArg;
    _v[4] = aArg;
  }

  void setRGB(double rArg, double gArg, double bArg) {
    _v[1] = rArg;
    _v[2] = gArg;
    _v[3] = bArg;
  }


  double &operator [](int idx) {
    return _v[idx];
  }

  const double &operator [](int idx) const {
    return _v[idx];
  }

  bool operator <(const LUTRGBAPoint& p) const {
    return this->pos()<p.pos();
  }

  bool operator >(const LUTRGBAPoint& p) const {
    return this->pos()>p.pos();
  }

private:
  double _v[5];
};



typedef std::vector<LUTRGBAPoint> LUTRGBAPointList;



class MLLUT_EXPORT LUTFLinear : public LUTFunction
{
public:
  
  // Set current version number
  ML_SET_ADDSTATE_VERSION(1);

  typedef enum {
    InterpolateRGB,          
    InterpolateHLS,          
    InterpolateHLSpos,       
    InterpolateHLSneg,       
    InterpolateConstant,     

    numColorInterpolation    
  } ColorInterpolation;

  static const char *ColorInterpolationNames[numColorInterpolation];


  LUTFLinear (void);

  


  virtual bool setPoints(const LUTRGBAPointList& points);

  const LUTRGBAPointList& getPoints() const { return _points; }

  LUTRGBAPointList& getModifiablePoints() { return _points; }

  void setVisualType(LUTVisualType visualType) { _visualType = visualType; changed(); }

  int insertPoint(const LUTRGBAPoint& point);

  void removePoint(int idx);

  const LUTRGBAPoint& getPoint(int idx) const;

  void setPoint(int idx, const LUTRGBAPoint& point);

  virtual double getStartIndex (void) const;

  virtual double getEndIndex (void) const;

  virtual ColorInterpolation getColorInterpolation (void) const { return _colorInterpolation; }

  virtual void setColorInterpolation (ColorInterpolation c) { _colorInterpolation = c; changed(); }

  void setAlphaFactor(float factor) {
    _alphaFactor = factor;
    changed();
  }

  float getAlphaFactor() const {
    return _alphaFactor;
  }

  bool relativeUsesNativeRange() const { return _relativeUsesNativeRange; }

  void setRelativeUsesNativeRange(bool flag) { _relativeUsesNativeRange = flag; }


  


  virtual bool isValid (void) const;

  virtual int getNativeMinIndex (void) const;

  virtual int getNativeMaxIndex (void) const;


  
protected:

  virtual void addStateToTree(TreeNode *parent) const;
  virtual void readStateFromTree(TreeNode *parent);
  


  virtual bool renderLUTNative (LUTDataBase *lutData, LUTIteratorBase *lutIterator) const;

  virtual bool renderLUTRescaled (LUTDataBase *lutData, LUTIteratorBase *lutIterator,
                                  double minIndex, double maxIndex) const;

  template <typename T>
  bool renderLUT (LUTData<T> *lutData, LUTIterator<T> *lutIterator, 
                  double startIndex, double endIndex) const;


  
  void copyPoint(int idx, double* array) const;


  LUTRGBAPointList _points;

  float _alphaFactor;

  bool  _relativeUsesNativeRange;

  ColorInterpolation _colorInterpolation;

  
  ML_CLASS_HEADER(LUTFLinear);

};


ML_END_NAMESPACE


#endif
// __mlLUTFLinear_H