mlLUTFLinear.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_LUTFLINEAR_H
#define ML_LUTFLINEAR_H
 

 
#include "mlLUTSystem.h"
#include "mlLUTFunction.h"
 
#include <mlFields.h>
 
#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);

  enum ColorInterpolation {
    InterpolateRGB,          
    InterpolateHLS,          
    InterpolateHLSpos,       
    InterpolateHLSneg,       
    InterpolateConstant,     
    InterpolateSRGB,         
  };

  static EnumValues<ColorInterpolation> getColorInterpolationValues();
 

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

 


  bool isValid (void) const override;

  double getNativeMinIndex (void) const override;

  double getNativeMaxIndex (void) const override;

 
 
protected:
 
  void addStateToTree(TreeNode *parent) const override;
  void readStateFromTree(TreeNode *parent) override;


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

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

  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