TransferFunction.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
// 
#ifndef TRANSFERFUNCTION_HPP
#define TRANSFERFUNCTION_HPP
 
#include <Config.hpp>
 
#include <Color.hpp>
 
#include <QMap>
#include <QObject>
#include <vector>
 
namespace mgx 
{
  class mgx_EXPORT TransferFunction 
                {
  public:
    enum Interpolation {
      RGB = 0,           
      HSV = 1,           
      CYCLIC_HSV = 2     
    };
  
    static const double epsilon;
  
    typedef Color<float> Colorf;
  
    typedef std::vector<std::pair<double, Colorf> > value_list;
  
    typedef QMap<double, int> key_map;
  
    TransferFunction(Interpolation interpolation = RGB);
  
    TransferFunction(const TransferFunction& copy);
  
    virtual ~TransferFunction() {
    }
  
 
    static TransferFunction scale(Colorf min, Colorf max, Interpolation interpolation = RGB);
    static TransferFunction hue_scale();
    static TransferFunction scale_gray() {
      return scale(Colorf(0, 0, 0, 0), Colorf(1, 1, 1, 1));
    }
    static TransferFunction scale_red() {
      return scale(Colorf(0, 0, 0, 0), Colorf(1, 0, 0, 1));
    }
    static TransferFunction scale_green() {
      return scale(Colorf(0, 0, 0, 0), Colorf(0, 1, 0, 1));
    }
    static TransferFunction scale_blue() {
      return scale(Colorf(0, 0, 0, 0), Colorf(0, 0, 1, 1));
    }
    static TransferFunction scale_yellow() {
      return scale(Colorf(0, 0, 0, 0), Colorf(1, 1, 0, 1));
    }
    static TransferFunction scale_cyan() {
      return scale(Colorf(0, 0, 0, 0), Colorf(0, 1, 1, 1));
    }
    static TransferFunction scale_purple() {
      return scale(Colorf(0, 0, 0, 0), Colorf(1, 0, 1, 1));
    }
    static TransferFunction constant_gray() {
      return scale(Colorf(1, 1, 1, 0), Colorf(1, 1, 1, 1));
    }
    static TransferFunction constant_red() {
      return scale(Colorf(1, 0, 0, 0), Colorf(1, 0, 0, 1));
    }
    static TransferFunction constant_green() {
      return scale(Colorf(0, 1, 0, 0), Colorf(0, 1, 0, 1));
    }
    static TransferFunction constant_blue() {
      return scale(Colorf(0, 0, 1, 0), Colorf(0, 0, 1, 1));
    }
    static TransferFunction constant_yellow() {
      return scale(Colorf(1, 1, 0, 0), Colorf(1, 1, 0, 1));
    }
    static TransferFunction constant_cyan() {
      return scale(Colorf(0, 1, 1, 0), Colorf(0, 1, 1, 1));
    }
    static TransferFunction constant_purple() {
      return scale(Colorf(1, 0, 1, 0), Colorf(1, 0, 1, 1));
    }
    static TransferFunction jet();
    static TransferFunction french_flag();
 
    static TransferFunction blackbody();
    static TransferFunction uniform_jet();
    static TransferFunction helix_warm();
    static TransferFunction helix_cool();
    static TransferFunction helix_full();
 
    static TransferFunction batlow_10();
    static TransferFunction parula();
  
    static TransferFunction load(QString spec);
    QString dump() const;
  
    void add_rgba_point(double pos, Colorf col);
  
    void add_hsva_point(double pos, Colorf col);
  
    void remove_point(double pos);
  
    size_t size() const {
      return values.size();
    }
  
    void move_point(double old_pos, double new_pos);
  
    double next_pos(double old_pos) const;
  
    double prev_pos(double old_pos) const;
  
    double operator[](int i) const;
  
    Colorf rgba_point(double position) const;
    Colorf hsva_point(double position) const;
  
    Colorf rgba(double position) const;
    Colorf hsva(double position) const;
    double alpha(double position) const;
  
    bool empty() const {
      return values.empty();
    }
  
    TransferFunction& operator=(const TransferFunction& other);
  
    bool operator==(const TransferFunction& other) const;
    bool operator!=(const TransferFunction& other) const;
  
    void reverse();
  
    void clear();
  
    void adjust(double minValue, double maxValue);
  
    Interpolation interpolation() const {
      return _interpolation;
    }
    void setInterpolation(Interpolation i);
    void setPointList(const value_list& lst);
  
  protected:
    Colorf interpolate(double position, double p1, Colorf col1, double p2, Colorf col2) const;
    void update_keys();
    Interpolation _interpolation;
  
    Colorf color(double position) const;
  
    void add_point(double pos, Colorf col);
  
    value_list values;
    key_map keys;
  
    bool clamp;
  
    Colorf exteriorColor;
  };
}
#endif