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