diff --git a/Modules/Core/include/mitkLookupTable.h b/Modules/Core/include/mitkLookupTable.h
index 0b4da26be0..682fbcd3b4 100644
--- a/Modules/Core/include/mitkLookupTable.h
+++ b/Modules/Core/include/mitkLookupTable.h
@@ -1,235 +1,269 @@
 /*===================================================================
 
 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 MITKLookupTable_H_HEADER_INCLUDED_C1EBD53D
-#define MITKLookupTable_H_HEADER_INCLUDED_C1EBD53D
+#ifndef mitkLookupTable_h
+#define mitkLookupTable_h
 
-#include <mitkCommon.h>
+#include "mitkCommon.h"
 #include <MitkCoreExports.h>
 
 #include <itkDataObject.h>
 #include <itkObjectFactory.h>
 
 #include <vtkLookupTable.h>
 #include <vtkSmartPointer.h>
 
 
 class vtkColorTransferFunction;
 class vtkPiecewiseFunction;
 
 namespace mitk
 {
 /**
  * @brief The LookupTable class mitk wrapper for a vtkLookupTable
  * @ingroup DataManagement
  *
  * This class can be used to color images with a LookupTable, such as the
  * vtkLookupTable.
  * @note If you want to use this as a property for an mitk::Image, make sure
  * to use the mitk::LookupTableProperty and set the mitk::RenderingModeProperty
  * to a mode which supports lookup tables (e.g. LOOKUPTABLE_COLOR). Make
  * sure to check the documentation of the mitk::RenderingModeProperty. For a
  * code example how to use the mitk::LookupTable check the
  * mitkImageVtkMapper2DLookupTableTest.cpp in Core\Code\Testing.
  */
 class MITKCORE_EXPORT LookupTable : public itk::DataObject
 {
 public:
+
   /**
-     *@brief Some convenient typedefs.
-     */
+   * @brief RawLookupTableType raw lookuptable typedef for convenience.
+   */
   typedef unsigned char RawLookupTableType;
 
   mitkClassMacro( LookupTable, itk::DataObject );
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /**
-     * @returns the associated vtkLookupTable
-     */
+   * @brief GetVtkLookupTable Getter for the internally wrapped vtkLookupTable.
+   */
   virtual vtkSmartPointer<vtkLookupTable> GetVtkLookupTable() const;
 
-  virtual RawLookupTableType * GetRawLookupTable() const;
+  /**
+   * @brief GetRawLookupTable Getter for the raw lookuptable array.
+   */
+  virtual RawLookupTableType* GetRawLookupTable() const;
 
+  /**
+   * @brief SetVtkLookupTable Setter for the internal lookuptable.
+   * @param lut The lookuptable.
+   */
   virtual void SetVtkLookupTable( vtkSmartPointer<vtkLookupTable> lut );
 
+  /**
+   * @brief ChangeOpacityForAll Set the opacity for all table values.
+   * @param opacity Opacity between 0.0 and 1.0.
+   */
   virtual void ChangeOpacityForAll( float opacity );
 
+  /**
+   * @brief ChangeOpacity Set the opacity for a specific table index.
+   * @param index The lookuptable index.
+   * @param opacity Opacity between 0.0 and 1.0.
+   */
   virtual void ChangeOpacity(int index, float opacity );
 
-  virtual void GetColor(int, double rgb[3]);
+  /**
+   * @brief GetColor convenience method wrapping the vtkLookupTable::GetColor() method.
+   *
+   * Map one value through the lookup table and return the color as an RGB array of doubles between 0 and 1.
+   * @param value The value you want to map.
+   * @param rgb RGB values between 0 and 1.
+   */
+  virtual void GetColor(double value, double rgb[3]);
 
-  virtual void GetTableValue(int, double rgba[4]);
+  /**
+   * @brief GetTableValue convenience method wrapping the vtkLookupTable::GetTableValue() method.
+   * @param index The index you want to get.
+   * @param rgba RGB values between 0 and 1.
+   */
+  virtual void GetTableValue(int index, double rgba[4]);
 
-  virtual void SetTableValue(int, double rgba[4]);
+  /**
+   * @brief SetTableValue convenience method wrapping the vtkLookupTable::SetTableValue() method.
+   * @param index The index you want to set.
+   * @param rgba RGB values between 0 and 1.
+   */
+  virtual void SetTableValue(int index, double rgba[4]);
 
 
   itkSetMacro(Window, float);
   itkSetMacro(Level, float);
   itkSetMacro(Opacity, float);
 
 
   /*!
     * \brief equality operator implementation
     */
   virtual bool operator==( const mitk::LookupTable& LookupTable ) const;
 
   /*!
     * \brief non equality operator implementation
     */
   virtual bool operator!=( const LookupTable& LookupTable ) const;
 
   /*!
     * \brief implementation necessary because operator made
     * private in itk::Object
     */
   virtual LookupTable& operator=( const LookupTable& LookupTable );
 
   /**
      * Updates the output information of the current object by calling
      * updateOutputInformation of the data objects source object.
      */
   virtual void UpdateOutputInformation( );
 
   /**
      * Sets the requested Region to the largest possible region.
      * This method is not implemented, since this is the default
      * behaviour of the itk pipeline and we do not support the
      * requested-region mechanism for lookup-tables
      */
   virtual void SetRequestedRegionToLargestPossibleRegion( );
 
   /**
      * Checks, if the requested region lies outside of the buffered region by
      * calling verifyRequestedRegion().
      */
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion( );
 
   /**
      * Checks if the requested region is completely contained in
      * the buffered region. Since we always want to process the lookup
      * table as a whole, this method always returns true
      */
   virtual bool VerifyRequestedRegion( );
 
   /**
      * This method has no effect for lookup tables, since we do
      * not support the region-mechanism
      */
   virtual void SetRequestedRegion(const itk::DataObject *data );
 
   LookupTable();
   virtual ~LookupTable();
   /**
      * \deprecatedSince{2014_03} Please use CreateColorTransferFunction() instead
      */
   DEPRECATED(void CreateColorTransferFunction(vtkColorTransferFunction*& colorFunction));
   /**
     * \deprecatedSince{2014_03} Please use CreateOpacityTransferFunction() instead
     */
   DEPRECATED(void CreateOpacityTransferFunction(vtkPiecewiseFunction*& opacityFunction));
   /**
    * \deprecatedSince{2014_03} Please use CreateGradientTransferFunction() instead
    */
   DEPRECATED(void CreateGradientTransferFunction(vtkPiecewiseFunction*& gradientFunction));
 
   vtkSmartPointer<vtkColorTransferFunction> CreateColorTransferFunction();
   vtkSmartPointer<vtkPiecewiseFunction> CreateOpacityTransferFunction();
   vtkSmartPointer<vtkPiecewiseFunction> CreateGradientTransferFunction();
 
   /**
    * @brief The LookupTableType enum for different predefined lookup tables.
    *
    * \li GRAYSCALE Our default level-window (sometimes referred to as window-level by other sources) setup for a test image looks like this:
    * \image html ExampleLevelWindowColor.png
    * \li INVERSE_GRAYSCALE Inverse LookupTable of GRAYSCALE.
    * \li HOT_IRON A LookupTable for red colors.
    * \li JET A LookupTable for JET color rendering.
    * \li LEGACY_BINARY A LookupTable for binary images.
    * \li LEGACY_RAINBOW_COLOR A rainbow-like LookupTable.
    * \li MULTILABEL A LookupTable for multilabel images.
    * \li PET_COLOR A LookupTable for PET color rendering.
    * \li PET_20 A LookupTable for PET_20 color rendering.
    *
    * The different LookupTableTypes can be applied in the MitkWorkbench via right-clicking
    * on an image and choosing a color map.
    */
   enum LookupTableType
   {
     GRAYSCALE,
     INVERSE_GRAYSCALE,
     HOT_IRON,
     JET,
     LEGACY_BINARY,
     LEGACY_RAINBOW_COLOR,
     MULTILABEL,
     PET_COLOR,
     PET_20
   };
 
   static const char* const typenameList[];
 
   /*!
      *  \brief Set the look-up table type by enum (or integer).
      *  \details Returns if the given type doesn't exist. Only changes the type if it is different
      *           from the current one.
      */
   virtual void SetType(const LookupTableType type);
 
   /*!
      *  \brief Set the look-up table type by string.
      *  \details Returns if the given type doesn't exist. Only changes the type if it is different
      *           from the current one.
      */
   virtual void SetType(const std::string& typeName);
 
   /*!
      *  \brief Return the current look-up table type as a string.
      */
   virtual const std::string GetActiveTypeAsString();
 protected:
 
   void PrintSelf(std::ostream &os, itk::Indent indent) const;
 
   LookupTable(const LookupTable& other);
 
   virtual void BuildGrayScaleLookupTable();
   virtual void BuildLegacyBinaryLookupTable();
   virtual void BuildLegacyRainbowColorLookupTable();
   virtual void BuildInverseGrayScaleLookupTable();
   virtual void BuildHotIronLookupTable();
   virtual void BuildJetLookupTable();
   virtual void BuildPETColorLookupTable();
   virtual void BuildPET20LookupTable();
   virtual void BuildMultiLabelLookupTable();
 
   vtkSmartPointer<vtkLookupTable> m_LookupTable;
 
   float m_Window;
 
   float m_Level;
 
   float m_Opacity;
 
   LookupTableType m_type;
 
 private:
 
   virtual itk::LightObject::Pointer InternalClone() const;
 };
 } // namespace mitk
 
-#endif /* LookupTable_H_HEADER_INCLUDED_C1EBD53D */
+#endif /* mitkLookupTable_h */
diff --git a/Modules/Core/src/DataManagement/mitkLookupTable.cpp b/Modules/Core/src/DataManagement/mitkLookupTable.cpp
index 35435a23e6..515a905005 100644
--- a/Modules/Core/src/DataManagement/mitkLookupTable.cpp
+++ b/Modules/Core/src/DataManagement/mitkLookupTable.cpp
@@ -1,567 +1,567 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #include "mitkLookupTable.h"
 #include <itkProcessObject.h>
 
 #include <vtkColorTransferFunction.h>
 #include <vtkPiecewiseFunction.h>
 
 #include <mitkLookupTableProperty.h>
 #include <Colortables/Jet.h>
 #include <Colortables/HotIron.h>
 #include <Colortables/PETColor.h>
 #include <Colortables/PET20.h>
 
 const char* const mitk::LookupTable::typenameList[] =
 {
   "Grayscale",
   "Inverse Grayscale",
   "Hot Iron",
   "Jet",
   "Legacy Binary",
   "Legacy Rainbow Color",
   "Multilabel",
   "PET Color",
   "PET 20",
   "END_OF_ARRAY" // Do not add typenames after this entry (see QmitkDataManagerView::ColormapMenuAboutToShow())
 };
 
 mitk::LookupTable::LookupTable():
   m_Window(0.0),
   m_Level(0.0),
   m_Opacity(1.0),
   m_type(mitk::LookupTable::GRAYSCALE)
 {
   m_LookupTable = vtkSmartPointer<vtkLookupTable>::New();
   this->BuildGrayScaleLookupTable();
 }
 
 mitk::LookupTable::LookupTable(const LookupTable& other)
   : itk::DataObject()
   , m_LookupTable(vtkSmartPointer<vtkLookupTable>::New())
 {
   m_LookupTable->DeepCopy(other.m_LookupTable);
 }
 
 mitk::LookupTable::~LookupTable()
 {
 }
 
 void mitk::LookupTable::SetVtkLookupTable( vtkSmartPointer<vtkLookupTable> lut )
 {
   if ((!lut) || (m_LookupTable == lut))
   {
     return;
   }
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::SetType(const mitk::LookupTable::LookupTableType type)
 {
   if (m_type == type)
     return;
 
   switch(type)
   {
   case (mitk::LookupTable::GRAYSCALE):
     this->BuildGrayScaleLookupTable();
     break;
   case (mitk::LookupTable::INVERSE_GRAYSCALE):
     this->BuildInverseGrayScaleLookupTable();
     break;
   case (mitk::LookupTable::HOT_IRON):
     this->BuildHotIronLookupTable();
     break;
   case (mitk::LookupTable::JET):
     this->BuildJetLookupTable();
     break;
   case (mitk::LookupTable::LEGACY_BINARY):
     this->BuildLegacyBinaryLookupTable();
     break;
   case (mitk::LookupTable::MULTILABEL):
     this->BuildMultiLabelLookupTable();
     break;
   case (mitk::LookupTable::PET_COLOR):
     this->BuildPETColorLookupTable();
     break;
   case (mitk::LookupTable::PET_20):
     this->BuildPET20LookupTable();
     break;
   case (mitk::LookupTable::LEGACY_RAINBOW_COLOR):
     this->BuildLegacyRainbowColorLookupTable();
     break;
   default:
     MITK_ERROR << "non-existing colormap";
     return;
   }
 
   m_type = type;
 }
 
 void mitk::LookupTable::SetType(const std::string& typeName)
 {
   int i = 0;
   std::string lutType = this->typenameList[i];
 
   while (lutType != "END_OF_ARRAY")
   {
     if (lutType == typeName)
     {
       this->SetType(static_cast<mitk::LookupTable::LookupTableType>(i));
     }
 
     lutType = this->typenameList[++i];
   }
 }
 
 const std::string mitk::LookupTable::GetActiveTypeAsString()
 {
   return std::string(typenameList[(int)m_type]);
 }
 
 void mitk::LookupTable::ChangeOpacityForAll( float opacity )
 {
 
   int noValues = m_LookupTable->GetNumberOfTableValues ();
 
   double rgba[ 4 ];
 
   for ( int i = 0;i < noValues;i++ )
   {
     m_LookupTable->GetTableValue ( i, rgba );
     rgba[ 3 ] = opacity;
     m_LookupTable->SetTableValue ( i, rgba );
   }
   this->Modified();  // need to call modified, since LookupTableProperty seems to be unchanged so no widget-update is executed
 }
 
 void mitk::LookupTable::ChangeOpacity(int index, float opacity )
 {
 
   int noValues = m_LookupTable->GetNumberOfTableValues ();
   if (index>noValues)
   {
     MITK_INFO << "could not change opacity. index exceed size of lut ... " << std::endl;
     return;
   }
 
   double rgba[ 4 ];
 
   m_LookupTable->GetTableValue ( index, rgba );
   rgba[ 3 ] = opacity;
   m_LookupTable->SetTableValue ( index, rgba );
 
   this->Modified();  // need to call modified, since LookupTableProperty seems to be unchanged so no widget-update is executed
 }
 
-void mitk::LookupTable::GetColor(int x, double rgb[3])
+void mitk::LookupTable::GetColor(double value, double rgb[3])
 {
-  this->GetVtkLookupTable()->GetColor(x,rgb);
+  this->GetVtkLookupTable()->GetColor(value,rgb);
 }
 
-void mitk::LookupTable::GetTableValue(int x, double rgba[4])
+void mitk::LookupTable::GetTableValue(int index, double rgba[4])
 {
-  this->GetVtkLookupTable()->GetTableValue(x,rgba);
+  this->GetVtkLookupTable()->GetTableValue(index,rgba);
 }
 
-void mitk::LookupTable::SetTableValue(int x, double rgba[4])
+void mitk::LookupTable::SetTableValue(int index, double rgba[4])
 {
-  this->GetVtkLookupTable()->SetTableValue(x,rgba);
+  this->GetVtkLookupTable()->SetTableValue(index,rgba);
 }
 
 vtkSmartPointer<vtkLookupTable> mitk::LookupTable::GetVtkLookupTable() const
 {
   return m_LookupTable;
 }
 
 mitk::LookupTable::RawLookupTableType * mitk::LookupTable::GetRawLookupTable() const
 {
   return m_LookupTable->GetPointer( 0 );
 }
 
 /*!
 * \brief equality operator inplementation
 */
 bool mitk::LookupTable::operator==( const mitk::LookupTable& other ) const
 {
   if ( m_LookupTable == other.GetVtkLookupTable())
     return true;
   vtkLookupTable* olut = other.GetVtkLookupTable();
   if (olut == NULL)
     return false;
 
   bool equal = (m_LookupTable->GetNumberOfColors() == olut->GetNumberOfColors())
       && (m_LookupTable->GetTableRange()[0] == olut->GetTableRange()[0])
       && (m_LookupTable->GetTableRange()[1] == olut->GetTableRange()[1])
       && (m_LookupTable->GetHueRange()[0] == olut->GetHueRange()[0])
       && (m_LookupTable->GetHueRange()[1] == olut->GetHueRange()[1])
       && (m_LookupTable->GetSaturationRange()[0] == olut->GetSaturationRange()[0])
       && (m_LookupTable->GetSaturationRange()[1] == olut->GetSaturationRange()[1])
       && (m_LookupTable->GetValueRange()[0] == olut->GetValueRange()[0])
       && (m_LookupTable->GetValueRange()[1] == olut->GetValueRange()[1])
       && (m_LookupTable->GetAlphaRange()[0] == olut->GetAlphaRange()[0])
       && (m_LookupTable->GetAlphaRange()[1] == olut->GetAlphaRange()[1])
       && (m_LookupTable->GetRamp() == olut->GetRamp())
       && (m_LookupTable->GetScale() == olut->GetScale())
       && (m_LookupTable->GetAlpha() == olut->GetAlpha())
       && (m_LookupTable->GetTable()->GetNumberOfTuples() == olut->GetTable()->GetNumberOfTuples());
   if (equal == false)
     return false;
   for (vtkIdType i=0; i < m_LookupTable->GetNumberOfTableValues(); i++)
   {
     bool tvequal = (m_LookupTable->GetTableValue(i)[0] == olut->GetTableValue(i)[0])
         && (m_LookupTable->GetTableValue(i)[1] == olut->GetTableValue(i)[1])
         && (m_LookupTable->GetTableValue(i)[2] == olut->GetTableValue(i)[2])
         && (m_LookupTable->GetTableValue(i)[3] == olut->GetTableValue(i)[3]);
     if (tvequal == false)
       return false;
   }
   return true;
 }
 
 /*!
 * \brief un-equality operator implementation
 */
 bool mitk::LookupTable::operator!=( const mitk::LookupTable& other ) const
 {
   return !(*this == other);
 }
 
 /*!
 * \brief assignment operator implementation
 */
 mitk::LookupTable& mitk::LookupTable::operator=( const mitk::LookupTable& LookupTable )
 {
   if ( this == &LookupTable )
   {
     return * this;
   }
   else
   {
     m_LookupTable = LookupTable.GetVtkLookupTable();
     return *this;
   }
 }
 
 void mitk::LookupTable::UpdateOutputInformation( )
 {
   if ( this->GetSource( ) )
   {
     this->GetSource( ) ->UpdateOutputInformation( );
   }
 }
 
 
 void mitk::LookupTable::SetRequestedRegionToLargestPossibleRegion( )
 {}
 
 
 bool mitk::LookupTable::RequestedRegionIsOutsideOfTheBufferedRegion( )
 {
   return false;
 }
 
 
 bool mitk::LookupTable::VerifyRequestedRegion( )
 {
   //normally we should check if the requested region lies within the
   //largest possible region. Since for lookup-tables we assume, that the
   //requested region is always the largest possible region, we can always
   //return true!
   return true;
 }
 
 
 void mitk::LookupTable::SetRequestedRegion(const itk::DataObject *)
 {
   //not implemented, since we always want to have the RequestedRegion
   //to be set to LargestPossibleRegion
 }
 
 vtkSmartPointer<vtkColorTransferFunction> mitk::LookupTable::CreateColorTransferFunction()
 {
   vtkSmartPointer<vtkColorTransferFunction> colorFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
 
   mitk::LookupTable::RawLookupTableType *rawLookupTable = this->GetRawLookupTable();
   int num_of_values = m_LookupTable->GetNumberOfTableValues();
 
   double* cols = new double[3*num_of_values];
   double* colsHead = cols;
 
   for (int i = 0; i<num_of_values; ++i)
   {
     *cols=static_cast<double>(*rawLookupTable)/255.0; ++cols; ++rawLookupTable;
     *cols=static_cast<double>(*rawLookupTable)/255.0; ++cols; ++rawLookupTable;
     *cols=static_cast<double>(*rawLookupTable)/255.0; ++cols; ++rawLookupTable;
     ++rawLookupTable;
   }
   colorFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values, colsHead);
   return colorFunction;
 }
 
 void mitk::LookupTable::CreateColorTransferFunction(vtkColorTransferFunction*& colorFunction)
 {
   colorFunction = this->CreateColorTransferFunction();
 }
 
 vtkSmartPointer<vtkPiecewiseFunction> mitk::LookupTable::CreateOpacityTransferFunction()
 {
   vtkSmartPointer<vtkPiecewiseFunction> opacityFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
 
   mitk::LookupTable::RawLookupTableType *rgba = this->GetRawLookupTable();
   int num_of_values=m_LookupTable->GetNumberOfTableValues();
 
   double *alphas = new double [num_of_values];
   double *alphasHead = alphas;
 
   rgba+=3;
   for(int i=0;i<num_of_values;++i)
   {
     *alphas=static_cast<double>(*rgba)/255.0; ++alphas; rgba+=4;
   }
 
   opacityFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values, alphasHead);
   return opacityFunction;
 }
 
 void mitk::LookupTable::CreateOpacityTransferFunction(vtkPiecewiseFunction*& opacityFunction)
 {
   opacityFunction = this->CreateOpacityTransferFunction();
 }
 
 vtkSmartPointer<vtkPiecewiseFunction> mitk::LookupTable::CreateGradientTransferFunction()
 {
   vtkSmartPointer<vtkPiecewiseFunction> gradientFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
 
   mitk::LookupTable::RawLookupTableType *rgba = this->GetRawLookupTable();
   int num_of_values=m_LookupTable->GetNumberOfTableValues();
 
   double *alphas = new double [num_of_values];
   double *alphasHead = alphas;
 
   rgba+=3;
   for(int i=0;i<num_of_values;++i)
   {
     *alphas=static_cast<double>(*rgba)/255.0; ++alphas; rgba+=4;
   }
 
   gradientFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values, alphasHead);
   return gradientFunction;
 }
 
 void mitk::LookupTable::CreateGradientTransferFunction(vtkPiecewiseFunction*& gradientFunction)
 {
   gradientFunction = this->CreateGradientTransferFunction();
 }
 
 void mitk::LookupTable::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   os << indent;
   m_LookupTable->PrintHeader(os, vtkIndent());
 }
 
 itk::LightObject::Pointer mitk::LookupTable::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   result->UnRegister();
   return result;
 }
 
 void mitk::LookupTable::BuildGrayScaleLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetRampToLinear();
   lut->SetSaturationRange( 0.0, 0.0 );
   lut->SetHueRange( 0.0, 0.0 );
   lut->SetValueRange( 0.0, 1.0 );
   lut->Build();
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildLegacyBinaryLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetRampToLinear();
   lut->SetSaturationRange( 0.0, 0.0 );
   lut->SetHueRange( 0.0, 0.0 );
   lut->SetValueRange( 0.0, 1.0 );
   lut->Build();
   lut->SetTableValue(0,0.0,0.0,0.0,0.0);
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildInverseGrayScaleLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetTableRange (0, 1);
   lut->SetSaturationRange (0, 0);
   lut->SetHueRange (0, 0);
   lut->SetValueRange (1, 0);
   lut->SetAlphaRange (1, 0);
   lut->Build();
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildHotIronLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetNumberOfTableValues(256);
   lut->Build();
 
   for( int i=0; i<256; i++)
   {
 
     lut->SetTableValue(i, (double)HotIron[i][0]/255.0, (double)HotIron[i][1]/255.0, (double)HotIron[i][2]/255.0, 1.0);
   }
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildJetLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetNumberOfTableValues(256);
   lut->Build();
 
   for (int i = 0; i < 256; i++)
   {
     lut->SetTableValue(i, (double)Jet[i][0] / 255.0, (double)Jet[i][1] / 255.0, (double)Jet[i][2] / 255.0, 1.0);
   }
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildPETColorLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetNumberOfTableValues(256);
   lut->SetTableRange ( (m_Level - m_Window/2.0), (m_Level + m_Window/2.0) );
   lut->Build();
 
   for( int i=0; i<256; i++)
   {
     lut->SetTableValue(i, (double)PETColor[i][0]/255.0, (double)PETColor[i][1]/255.0, (double)PETColor[i][2]/255.0, 1.0);
   }
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildPET20LookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetNumberOfTableValues(256);
   lut->SetTableRange ( (m_Level - m_Window/2.0), (m_Level + m_Window/2.0) );
   lut->Build();
 
   for( int i=0; i<256; i++)
   {
     lut->SetTableValue(i, (double)PET20[i][0]/255.0, (double)PET20[i][1]/255.0, (double)PET20[i][2]/255.0, 1.0);
   }
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildMultiLabelLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetNumberOfTableValues (65536);
   lut->SetTableRange ( 0, 65536 );
   lut->SetTableValue (0, 0.0, 0.0, 0.0, 0.0); // background
 
   lut->SetTableValue (1, 1.0, 1.0, 0.0, 0.4);
   lut->SetTableValue (2, 0.0, 1.0, 0.0, 0.4);
   lut->SetTableValue (3, 0.0, 0.0, 1.0, 0.4);
   lut->SetTableValue (4, 1.0, 1.0, 0.4, 0.4);
   lut->SetTableValue (5, 0.0, 0.4, 0.7, 0.4);
   lut->SetTableValue (6, 1.0, 0.0, 1.0, 0.4);
 
   lut->SetTableValue (7, 1.0, 0.5, 0.0, 0.4);
   lut->SetTableValue (8, 0.0, 1.0, 0.5, 0.4);
   lut->SetTableValue (9, 0.5, 0.0, 1.0, 0.4);
   lut->SetTableValue (10, 1.0, 1.0, 0.5, 0.4);
   lut->SetTableValue (11, 0.5, 1.0, 1.0, 0.4);
   lut->SetTableValue (12, 1.0, 0.5, 0.6, 0.4);
   lut->SetTableValue (13, 1.0, 0.3, 0.3, 0.4);
   lut->SetTableValue (14, 0.4, 0.7, 1.0, 0.4);
   lut->SetTableValue (15, 0.4, 0.5, 1.0, 0.4);
   lut->SetTableValue (16, 0.8, 0.5, 1.0, 0.4);
   lut->SetTableValue (17, 1.0, 0.3, 1.0, 0.4);
   lut->SetTableValue (18, 1.0, 0.5, 0.6, 0.4);
   lut->SetTableValue (19, 1.0, 0.5, 0.4, 0.4);
   lut->SetTableValue (20, 0.4, 0.5, 0.4, 0.4);
   lut->SetTableValue (21, 1.0, 0.5, 0.76, 0.4);
   lut->SetTableValue (22, 0.76, 0.4, 0.4, 0.4);
   lut->SetTableValue (23, 1.0, 0.5, 0.4, 0.4);
   lut->SetTableValue (24, 0.76, 0.3, 0.4, 0.4);
   lut->SetTableValue (25, 1.0, 0.3, 0.4, 0.4);
 
   for (int i = 26; i < 65536; i++)
   {
     if (i%12 == 0)
       lut->SetTableValue (i, 1.0, 0.0, 0.0, 0.4);
     else if (i%12 == 1)
       lut->SetTableValue (i, 0.0, 1.0, 0.0, 0.4);
     else if (i%12 == 2)
       lut->SetTableValue (i, 0.0, 0.0, 1.0, 0.4);
     else if (i%12 == 3)
       lut->SetTableValue (i, 1.0, 1.0, 0.0, 0.4);
     else if (i%12 == 4)
       lut->SetTableValue (i, 0.0, 1.0, 1.0, 0.4);
     else if (i%12 == 5)
       lut->SetTableValue (i, 1.0, 0.0, 1.0, 0.4);
     else if (i%12 == 6)
       lut->SetTableValue (i, 1.0, 0.5, 0.0, 0.4);
     else if (i%12 == 7)
       lut->SetTableValue (i, 0.0, 1.0, 0.5, 0.4);
     else if (i%12 == 8)
       lut->SetTableValue (i, 0.5, 0.0, 1.0, 0.4);
     else if (i%12 == 9)
       lut->SetTableValue (i, 1.0, 1.0, 0.5, 0.4);
     else if (i%12 == 10)
       lut->SetTableValue (i, 0.5, 1.0, 1.0, 0.4);
     else if (i%12 == 11)
       lut->SetTableValue (i, 1.0, 0.5, 1.0, 0.4);
   }
 
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LookupTable::BuildLegacyRainbowColorLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   lut->SetRampToLinear();
   lut->SetHueRange(0.6667, 0.0);
   lut->SetTableRange(0.0, 20.0);
   lut->Build();
 
   m_LookupTable = lut;
   this->Modified();
 }