mitk: mitkTransferFunction.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 #include "mitkTransferFunction.h"
00019 #include "mitkImageToItk.h"
00020 #include "mitkHistogramGenerator.h"
00021 
00022 #include <itkRGBPixel.h>
00023 
00024 #include <vector>
00025 
00026 namespace mitk
00027 {
00028 
00029 
00030 TransferFunction::TransferFunction()
00031 {
00032   m_ScalarOpacityFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
00033   m_ColorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
00034   m_GradientOpacityFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
00035   
00036   m_ScalarOpacityFunction->Initialize();
00037   m_ScalarOpacityFunction->AddPoint(0,1);
00038 
00039   m_GradientOpacityFunction->Initialize();
00040   m_GradientOpacityFunction->AddPoint(0,1);
00041 
00042   m_ColorTransferFunction->RemoveAllPoints();
00043   m_ColorTransferFunction->SetColorSpaceToHSV();
00044   m_ColorTransferFunction->AddRGBPoint(0,1,1,1);
00045 }
00046 
00047 TransferFunction::~TransferFunction() 
00048 {
00049 }
00050 
00051 bool TransferFunction::operator==(Self& other)
00052 {
00053   if ((m_Min != other.m_Min) || (m_Max != other.m_Max))
00054     return false;
00055   
00056   bool sizes = (m_ScalarOpacityFunction->GetSize() == other.m_ScalarOpacityFunction->GetSize())
00057             && (m_GradientOpacityFunction->GetSize() == other.m_GradientOpacityFunction->GetSize())
00058             && (m_ColorTransferFunction->GetSize() == other.m_ColorTransferFunction->GetSize());
00059   if (sizes == false)
00060     return false;
00061 
00062   for (int i = 0; i < m_ScalarOpacityFunction->GetSize(); i++ )
00063   {
00064     double myVal[4];
00065     double otherVal[4];
00066     m_ScalarOpacityFunction->GetNodeValue(i, myVal);
00067     other.m_ScalarOpacityFunction->GetNodeValue(i, otherVal);
00068     bool equal = (myVal[0] == otherVal[0])
00069               && (myVal[1] == otherVal[1])
00070               && (myVal[2] == otherVal[2])
00071               && (myVal[3] == otherVal[3]);
00072     if (equal == false)
00073       return false;
00074   }
00075   for (int i = 0; i < m_GradientOpacityFunction->GetSize(); i++ )
00076   {
00077     double myVal[4];
00078     double otherVal[4];
00079     m_GradientOpacityFunction->GetNodeValue(i, myVal);
00080     other.m_GradientOpacityFunction->GetNodeValue(i, otherVal);
00081     bool equal = (myVal[0] == otherVal[0])
00082       && (myVal[1] == otherVal[1])
00083       && (myVal[2] == otherVal[2])
00084       && (myVal[3] == otherVal[3]);
00085     if (equal == false)
00086       return false;
00087   }
00088   for (int i = 0; i < m_ColorTransferFunction->GetSize(); i++ )
00089   {
00090     double myVal[6];
00091     double otherVal[6];
00092     m_ColorTransferFunction->GetNodeValue(i, myVal);
00093     other.m_ColorTransferFunction->GetNodeValue(i, otherVal);
00094     bool equal = (myVal[0] == otherVal[0]) // X
00095       && (myVal[1] == otherVal[1])  // R
00096       && (myVal[2] == otherVal[2])  // G
00097       && (myVal[3] == otherVal[3])  // B
00098       && (myVal[4] == otherVal[4])  // midpoint
00099       && (myVal[5] == otherVal[5]); // sharpness
00100     if (equal == false)
00101       return false;
00102   }
00103   return true;
00104 }
00105 
00106 void TransferFunction::SetScalarOpacityPoints(TransferFunction::ControlPoints points)
00107 {
00108   m_ScalarOpacityFunction->RemoveAllPoints();
00109   for(unsigned int i=0; i<=points.size()-1;i++)
00110   {
00111     this->AddScalarOpacityPoint(points[i].first, points[i].second);
00112   }
00113 }
00114 
00115 
00116 void TransferFunction::SetGradientOpacityPoints(TransferFunction::ControlPoints points)
00117 {
00118   m_GradientOpacityFunction->RemoveAllPoints();
00119   for(unsigned int i=0; i<=points.size()-1;i++)
00120   {
00121     this->AddGradientOpacityPoint(points[i].first, points[i].second);
00122   }
00123 }
00124 
00125 
00126 void TransferFunction::SetRGBPoints(TransferFunction::RGBControlPoints rgbpoints)
00127 {
00128   m_ColorTransferFunction->RemoveAllPoints();
00129   for(unsigned int i=0; i<=rgbpoints.size()-1;i++)
00130   {
00131     this->AddRGBPoint(rgbpoints[i].first, rgbpoints[i].second[0], 
00132       rgbpoints[i].second[1], rgbpoints[i].second[2]);
00133   }  
00134 }
00135 
00136 void TransferFunction::AddScalarOpacityPoint(double x, double value)
00137 { 
00138   m_ScalarOpacityFunction->AddPoint(x, value);
00139 }
00140   
00141 
00142 void TransferFunction::AddGradientOpacityPoint(double x, double value)
00143 { 
00144   m_GradientOpacityFunction->AddPoint(x, value);
00145 }
00146 
00147 
00148 void TransferFunction::AddRGBPoint(double x, double r, double g, double b)
00149 {
00150   m_ColorTransferFunction->AddRGBPoint(x, r, g, b);
00151 }
00152 
00153 
00154 TransferFunction::ControlPoints &TransferFunction::GetScalarOpacityPoints()
00155 {
00156   // Retrieve data points from VTK transfer function and store them in a vector
00157   m_ScalarOpacityPoints.clear();
00158   vtkFloatingPointType *data = m_ScalarOpacityFunction->GetDataPointer();
00159   for ( int i = 0; i < m_ScalarOpacityFunction->GetSize(); ++i )
00160   {
00161     m_ScalarOpacityPoints.push_back( std::make_pair( data[i*2], data[i*2+1] ));
00162   }
00163 
00164   return m_ScalarOpacityPoints;
00165 }
00166 
00167 
00168 TransferFunction::ControlPoints &TransferFunction::GetGradientOpacityPoints()
00169 {
00170   // Retrieve data points from VTK transfer function and store them in a vector
00171   m_GradientOpacityPoints.clear();
00172   vtkFloatingPointType *data = m_GradientOpacityFunction->GetDataPointer();
00173   for ( int i = 0; i < m_GradientOpacityFunction->GetSize(); ++i )
00174   {
00175     m_GradientOpacityPoints.push_back( std::make_pair( data[i*2], data[i*2+1] ));
00176   }
00177 
00178   return m_GradientOpacityPoints;
00179 }
00180 
00181 
00182 TransferFunction::RGBControlPoints &TransferFunction::GetRGBPoints()
00183 {
00184   // Retrieve data points from VTK transfer function and store them in a vector
00185   m_RGBPoints.clear();
00186   vtkFloatingPointType *data = m_ColorTransferFunction->GetDataPointer();
00187   for ( int i = 0; i < m_ColorTransferFunction->GetSize(); ++i )
00188   {
00189     double rgb[] = { data[i*4+1], data[i*4+2], data[i*4+3] };
00190     m_RGBPoints.push_back( std::make_pair( data[i*4], rgb ));
00191   }
00192 
00193   return m_RGBPoints;
00194 }
00195 
00196 
00197 int TransferFunction::RemoveScalarOpacityPoint(double x)
00198 {
00199   return m_ScalarOpacityFunction->RemovePoint(x);
00200 }
00201 
00202 
00203 int TransferFunction::RemoveGradientOpacityPoint(double x)
00204 {
00205   return m_GradientOpacityFunction->RemovePoint(x);
00206 }
00207 
00208 
00209 int TransferFunction::RemoveRGBPoint(double x)
00210 {
00211   return m_ColorTransferFunction->RemovePoint(x);
00212 }
00213 
00214 
00215 void TransferFunction::ClearScalarOpacityPoints()
00216 {
00217   m_ScalarOpacityFunction->RemoveAllPoints();
00218 }
00219   
00220 
00221 void TransferFunction::ClearGradientOpacityPoints()
00222 {
00223   m_GradientOpacityFunction->RemoveAllPoints();
00224 }
00225 
00226 
00227 void TransferFunction::ClearRGBPoints()
00228 {
00229   m_ColorTransferFunction->RemoveAllPoints();
00230 }
00231 
00232 
00233 void TransferFunction::InitializeByItkHistogram(
00234   const itk::Statistics::Histogram<double>* histogram)
00235 {
00236   m_Histogram = histogram;
00237   m_Min = (int)GetHistogram()->GetBinMin(0,0);
00238   m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
00239   
00240   /*
00241   m_ScalarOpacityFunction->Initialize();
00242   m_ScalarOpacityFunction->AddPoint(m_Min,0.0);
00243   m_ScalarOpacityFunction->AddPoint(0.0,0.0);
00244   m_ScalarOpacityFunction->AddPoint(m_Max,1.0);
00245   m_GradientOpacityFunction->Initialize();
00246   m_GradientOpacityFunction->AddPoint(m_Min,0.0);
00247   m_GradientOpacityFunction->AddPoint(0.0,1.0);
00248   m_GradientOpacityFunction->AddPoint((m_Max*0.125),1.0);
00249   m_GradientOpacityFunction->AddPoint((m_Max*0.2),1.0);
00250   m_GradientOpacityFunction->AddPoint((m_Max*0.25),1.0);
00251   m_GradientOpacityFunction->AddPoint(m_Max,1.0);
00252   m_ColorTransferFunction->RemoveAllPoints();
00253   m_ColorTransferFunction->AddRGBPoint(m_Min,1,0,0);
00254   m_ColorTransferFunction->AddRGBPoint(m_Max,1,1,0);  
00255   m_ColorTransferFunction->SetColorSpaceToHSV();
00256   MITK_INFO << "min/max in tf-c'tor:" << m_Min << "/" << m_Max << std::endl;
00257   */
00258 }
00259 
00260 void TransferFunction::InitializeByMitkImage( const Image * image )
00261 {
00262   HistogramGenerator::Pointer histGen= HistogramGenerator::New();
00263   histGen->SetImage(image);
00264   histGen->SetSize(256);
00265   histGen->ComputeHistogram();
00266   m_Histogram = histGen->GetHistogram();
00267   m_Min = (int)GetHistogram()->GetBinMin(0,0);
00268   m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
00269   m_ScalarOpacityFunction->Initialize();
00270   m_ScalarOpacityFunction->AddPoint(m_Min,0.0);
00271   m_ScalarOpacityFunction->AddPoint(0.0,0.0);
00272   m_ScalarOpacityFunction->AddPoint(m_Max,1.0);
00273   m_GradientOpacityFunction->Initialize();
00274   m_GradientOpacityFunction->AddPoint(m_Min,0.0);
00275   m_GradientOpacityFunction->AddPoint(0.0,1.0);
00276   m_GradientOpacityFunction->AddPoint((m_Max*0.125),1.0);
00277   m_GradientOpacityFunction->AddPoint((m_Max*0.2),1.0);
00278   m_GradientOpacityFunction->AddPoint((m_Max*0.25),1.0);
00279   m_GradientOpacityFunction->AddPoint(m_Max,1.0);
00280   m_ColorTransferFunction->RemoveAllPoints();
00281   m_ColorTransferFunction->AddRGBPoint(m_Min,1,0,0);
00282   m_ColorTransferFunction->AddRGBPoint(m_Max,1,1,0);  
00283   m_ColorTransferFunction->SetColorSpaceToHSV();
00284   //MITK_INFO << "min/max in tf-c'tor:" << m_Min << "/" << m_Max << std::endl;
00285 }
00286 
00287 
00288 void TransferFunction::InitializeHistogram( const Image * image )
00289 {
00290   HistogramGenerator::Pointer histGen= HistogramGenerator::New();
00291   histGen->SetImage(image);
00292   histGen->SetSize(256);
00293   histGen->ComputeHistogram();
00294   m_Histogram = histGen->GetHistogram();
00295   m_Min = (int)GetHistogram()->GetBinMin(0,0);
00296   m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
00297 }
00298 }// namespace