mitkTransferFunction.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED
#define MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED

#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();
    virtual ~TransferFunction();

    TransferFunction(const TransferFunction &other);

    virtual itk::LightObject::Pointer InternalClone() const override;

    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 /* MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED */