mitkTransferFunction.h

Go to the documentation of this file.

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

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

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

#ifndef MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED
#define MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED

#include "mitkHistogramGenerator.h"
#include "mitkCommon.h"
#include "mitkImage.h"

#include <itkObject.h>
#include <itkRGBPixel.h>
#include <itkHistogram.h>

#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkSmartPointer.h>

#include <vector>
#include <algorithm>
#include <set>


namespace mitk {

class MITK_CORE_EXPORT TransferFunction : public itk::Object
{
public:
  typedef std::vector<std::pair<double, double> > ControlPoints;
  typedef std::vector<std::pair<double, itk::RGBPixel<double> > > RGBControlPoints;

  
  mitkClassMacro(TransferFunction, itk::DataObject);

  itkNewMacro(Self);


  itkSetMacro(Min,int);

  itkSetMacro(Max,int);

  itkGetMacro(Min,int);

  itkGetMacro(Max,int);

  itkGetMacro(ScalarOpacityFunction,vtkPiecewiseFunction*); 

  itkGetMacro(GradientOpacityFunction,vtkPiecewiseFunction*); 

  itkGetMacro(ColorTransferFunction,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();
    
  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 */