mitkTransferFunction.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkTransferFunction_h
#define mitkTransferFunction_h
 
#include <mitkHistogramGenerator.h>
#include <mitkImage.h>
#include <MitkCoreExports.h>
 
#include <itkHistogram.h>
#include <itkObject.h>
#include <itkRGBPixel.h>
 
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkSmartPointer.h>
 
#include <algorithm>
#include <set>
#include <vector>
 
namespace mitk
{
  class MITKCORE_EXPORT TransferFunction : public itk::Object
  {
  public:
    typedef std::vector<std::pair<double, double>> ControlPoints;
 
    typedef std::vector<std::pair<double, itk::RGBPixel<double>>> RGBControlPoints;
 
    mitkClassMacroItkParent(TransferFunction, itk::DataObject);
 
    itkFactorylessNewMacro(Self);
 
    itkCloneMacro(Self);
 
      itkSetMacro(Min, int);
 
    itkSetMacro(Max, int);
 
    itkGetMacro(Min, int);
 
    itkGetMacro(Max, int);
 
    itkGetMacro(ScalarOpacityFunction, vtkPiecewiseFunction *);
 
    itkGetMacro(GradientOpacityFunction, vtkPiecewiseFunction *);
 
    itkGetMacro(ColorTransferFunction, vtkColorTransferFunction *);
    itkSetMacro(ColorTransferFunction, vtkSmartPointer<vtkColorTransferFunction>);
 
    itkGetConstObjectMacro(Histogram, HistogramGenerator::HistogramType);
 
    void InitializeByMitkImage(const mitk::Image *image);
 
    void InitializeByItkHistogram(const itk::Statistics::Histogram<double> *histogram);
 
    void InitializeHistogram(const mitk::Image *image);
 
    void SetScalarOpacityPoints(TransferFunction::ControlPoints points);
 
    void SetGradientOpacityPoints(TransferFunction::ControlPoints points);
 
    void SetRGBPoints(TransferFunction::RGBControlPoints rgbpoints);
 
    void AddScalarOpacityPoint(double x, double value);
 
    void AddGradientOpacityPoint(double x, double value);
 
    void AddRGBPoint(double x, double r, double g, double b);
 
    TransferFunction::ControlPoints &GetScalarOpacityPoints();
 
    TransferFunction::ControlPoints &GetGradientOpacityPoints();
 
    TransferFunction::RGBControlPoints &GetRGBPoints();
 
    int RemoveScalarOpacityPoint(double x);
 
    int RemoveGradientOpacityPoint(double x);
 
    int RemoveRGBPoint(double x);
 
    void ClearScalarOpacityPoints();
 
    void ClearGradientOpacityPoints();
 
    void ClearRGBPoints();
 
    bool operator==(Self &other);
 
  protected:
    TransferFunction();
    ~TransferFunction() override;
 
    TransferFunction(const Self &other);
 
    mitkCloneMacro(Self);
 
    void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
    vtkSmartPointer<vtkPiecewiseFunction> m_ScalarOpacityFunction;
 
    vtkSmartPointer<vtkPiecewiseFunction> m_GradientOpacityFunction;
 
    vtkSmartPointer<vtkColorTransferFunction> m_ColorTransferFunction;
 
    int m_Min;
 
    int m_Max;
 
    mitk::HistogramGenerator::HistogramType::ConstPointer m_Histogram;
 
  private:
    TransferFunction::ControlPoints m_ScalarOpacityPoints;
 
    TransferFunction::ControlPoints m_GradientOpacityPoints;
 
    TransferFunction::RGBControlPoints m_RGBPoints;
  };
}
 
#endif