diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
index 5bd5d6d259..2218176cdb 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,1163 +1,1087 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //MITK
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkResliceMethodProperty.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkPixelType.h>
 //#include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include "mitkImageStatisticsHolder.h"
 #include "mitkPlaneClipping.h"
 
 //MITK Rendering
 #include "mitkImageVtkMapper2D.h"
 #include "vtkMitkThickSlicesFilter.h"
 #include "vtkMitkLevelWindowFilter.h"
 #include "vtkNeverTranslucentTexture.h"
-#include "vtkMitkShaderTexture.h"
-#include "vtkImageToImageFilter.h"
-
-#include <mitkIShaderRepository.h>
 
 //VTK
 #include <vtkProperty.h>
 #include <vtkTransform.h>
 #include <vtkMatrix4x4.h>
 #include <vtkLookupTable.h>
 #include <vtkImageData.h>
 #include <vtkPoints.h>
 #include <vtkGeneralTransform.h>
 #include <vtkImageExtractComponents.h>
 #include <vtkImageReslice.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkPlaneSource.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkCellArray.h>
 #include <vtkCamera.h>
 #include <vtkColorTransferFunction.h>
 
 //ITK
 #include <itkRGBAPixel.h>
 #include <mitkRenderingModeProperty.h>
 
 mitk::ImageVtkMapper2D::ImageVtkMapper2D()
 {
 }
 
 mitk::ImageVtkMapper2D::~ImageVtkMapper2D()
 {
   //The 3D RW Mapper (Geometry2DDataVtkMapper3D) is listening to this event,
   //in order to delete the images from the 3D RW.
   this->InvokeEvent( itk::DeleteEvent() );
 }
 
 //set the two points defining the textured plane according to the dimension and spacing
 void mitk::ImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   //Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   //plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   //These two points define the axes of the plane in combination with the origin.
   //Point 1 is the x-axis and point 2 the y-axis.
   //Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1] , planeBounds[2], depth); //P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); //P2: (xMin, yMax, depth)
 }
 
 float mitk::ImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer* renderer)
 {
   //get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   //Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange*0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty( "layer", layer, renderer);
   //add the layer property for each image to render images with a higher layer on top of the others
   depth += layer*10; //*10: keep some room for each image (e.g. for QBalls in between)
   if(depth > 0.0f) {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 const mitk::Image* mitk::ImageVtkMapper2D::GetInput( void )
 {
   return static_cast< const mitk::Image * >( GetDataNode()->GetData() );
 }
 
 vtkProp* mitk::ImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actors;
 }
 
 
 
 void mitk::ImageVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
   mitk::DataNode* datanode = this->GetDataNode();
 
   if ( input == NULL || input->IsInitialized() == false )
   {
     return;
   }
 
   //check if there is a valid worldGeometry
   const Geometry2D *worldGeometry = renderer->GetCurrentWorldGeometry2D();
   if( ( worldGeometry == NULL ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))
   {
     return;
   }
 
   input->Update();
 
   // early out if there is no intersection of the current rendering geometry
   // and the geometry of the image that is to be rendered.
   if ( !RenderingGeometryIntersectsImage( worldGeometry, input->GetSlicedGeometry() ) )
   {
     // set image to NULL, to clear the texture in 3D, because
     // the latest image is used there if the plane is out of the geometry
     // see bug-13275
     localStorage->m_ReslicedImage = NULL;
     localStorage->m_Mapper->SetInputData( localStorage->m_EmptyPolyData );
     return;
   }
 
 
   //set main input for ExtractSliceFilter
   localStorage->m_Reslicer->SetInput(input);
   localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
   localStorage->m_Reslicer->SetTimeStep( this->GetTimestep() );
 
 
   //set the transformation of the image to adapt reslice axis
   localStorage->m_Reslicer->SetResliceTransformByGeometry( input->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() ) );
 
 
   //is the geometry of the slice based on the input image or the worldgeometry?
   bool inPlaneResampleExtentByGeometry = false;
   datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
   localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
 
 
   // Initialize the interpolation mode for resampling; switch to nearest
   // neighbor if the input image is too small.
   if ( (input->GetDimension() >= 3) && (input->GetDimension(2) > 1) )
   {
     VtkResliceInterpolationProperty *resliceInterpolationProperty;
     datanode->GetProperty(
           resliceInterpolationProperty, "reslice interpolation" );
 
     int interpolationMode = VTK_RESLICE_NEAREST;
     if ( resliceInterpolationProperty != NULL )
     {
       interpolationMode = resliceInterpolationProperty->GetInterpolation();
     }
 
     switch ( interpolationMode )
     {
     case VTK_RESLICE_NEAREST:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
       break;
     case VTK_RESLICE_LINEAR:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
       break;
     case VTK_RESLICE_CUBIC:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
       break;
     }
   }
   else
   {
     localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
   }
 
   //set the vtk output property to true, makes sure that no unneeded mitk image convertion
   //is done.
   localStorage->m_Reslicer->SetVtkOutputRequest(true);
 
 
   //Thickslicing
   int thickSlicesMode = 0;
   int thickSlicesNum = 1;
   // Thick slices parameters
   if( input->GetPixelType().GetNumberOfComponents() == 1 ) // for now only single component are allowed
   {
     DataNode *dn=renderer->GetCurrentWorldGeometry2DNode();
     if(dn)
     {
       ResliceMethodProperty *resliceMethodEnumProperty=0;
 
       if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )
         thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
 
       IntProperty *intProperty=0;
       if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty )
       {
         thickSlicesNum = intProperty->GetValue();
         if(thickSlicesNum < 1) thickSlicesNum=1;
         if(thickSlicesNum > 10) thickSlicesNum=10;
       }
     }
     else
     {
       MITK_WARN << "no associated widget plane data tree node found";
     }
   }
 
   const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( worldGeometry );
 
   if(thickSlicesMode > 0)
   {
     double dataZSpacing = 1.0;
 
     Vector3D normInIndex, normal;
 
     if ( planeGeometry != NULL ){
       normal = planeGeometry->GetNormal();
     }else{
       const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * >(worldGeometry);
       if(abstractGeometry != NULL)
         normal = abstractGeometry->GetPlane()->GetNormal();
       else
         return; //no fitting geometry set
     }
     normal.Normalize();
 
     input->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() )->WorldToIndex( normal, normInIndex );
 
     dataZSpacing = 1.0 / normInIndex.GetNorm();
 
     localStorage->m_Reslicer->SetOutputDimensionality( 3 );
     localStorage->m_Reslicer->SetOutputSpacingZDirection(dataZSpacing);
     localStorage->m_Reslicer->SetOutputExtentZDirection( -thickSlicesNum, 0+thickSlicesNum );
 
     // Do the reslicing. Modified() is called to make sure that the reslicer is
     // executed even though the input geometry information did not change; this
     // is necessary when the input /em data, but not the /em geometry changes.
     localStorage->m_TSFilter->SetThickSliceMode( thickSlicesMode-1 );
     localStorage->m_TSFilter->SetInputData( localStorage->m_Reslicer->GetVtkOutput() );
 
     //vtkFilter=>mitkFilter=>vtkFilter update mechanism will fail without calling manually
     localStorage->m_Reslicer->Modified();
     localStorage->m_Reslicer->Update();
 
     localStorage->m_TSFilter->Modified();
     localStorage->m_TSFilter->Update();
     localStorage->m_ReslicedImage = localStorage->m_TSFilter->GetOutput();
   }
   else
   {
     //this is needed when thick mode was enable bevore. These variable have to be reset to default values
     localStorage->m_Reslicer->SetOutputDimensionality( 2 );
     localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
     localStorage->m_Reslicer->SetOutputExtentZDirection( 0, 0 );
 
 
     localStorage->m_Reslicer->Modified();
     //start the pipeline with updating the largest possible, needed if the geometry of the input has changed
     localStorage->m_Reslicer->UpdateLargestPossibleRegion();
     localStorage->m_ReslicedImage = localStorage->m_Reslicer->GetVtkOutput();
   }
 
   // Bounds information for reslicing (only reuqired if reference geometry
   // is present)
   //this used for generating a vtkPLaneSource with the right size
   double sliceBounds[6];
   for ( int i = 0; i < 6; ++i )
   {
     sliceBounds[i] = 0.0;
   }
   localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
 
   //get the spacing of the slice
   localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
 
   // calculate minimum bounding rect of IMAGE in texture
   {
     double textureClippingBounds[6];
     for ( int i = 0; i < 6; ++i )
     {
       textureClippingBounds[i] = 0.0;
     }
     // Calculate the actual bounds of the transformed plane clipped by the
     // dataset bounding box; this is required for drawing the texture at the
     // correct position during 3D mapping.
     mitk::PlaneClipping::CalculateClippedPlaneBounds( input->GetGeometry(), planeGeometry, textureClippingBounds );
 
     textureClippingBounds[0] = static_cast< int >( textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5 );
     textureClippingBounds[1] = static_cast< int >( textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5 );
     textureClippingBounds[2] = static_cast< int >( textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5 );
     textureClippingBounds[3] = static_cast< int >( textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5 );
 
     //clipping bounds for cutting the image
     localStorage->m_LevelWindowFilter->SetClippingBounds(textureClippingBounds);
   }
 
   //get the number of scalar components to distinguish between different image types
   int numberOfComponents = localStorage->m_ReslicedImage->GetNumberOfScalarComponents();
   //get the binary property
   bool binary = false;
   bool binaryOutline = false;
   datanode->GetBoolProperty( "binary", binary, renderer );
   if(binary) //binary image
   {
     datanode->GetBoolProperty( "outline binary", binaryOutline, renderer );
     if(binaryOutline) //contour rendering
     {
       if ( input->GetPixelType().GetBpe() <= 8 )
       {
         //generate contours/outlines
         localStorage->m_OutlinePolyData = CreateOutlinePolyData(renderer);
 
         float binaryOutlineWidth(1.0);
         if ( datanode->GetFloatProperty( "outline width", binaryOutlineWidth, renderer ) )
         {
           if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
           {
             float binaryOutlineShadowWidth(1.5);
             datanode->GetFloatProperty( "outline shadow width", binaryOutlineShadowWidth, renderer );
 
             dynamic_cast<vtkActor*>(localStorage->m_Actors->GetParts()->GetItemAsObject(0))
                 ->GetProperty()->SetLineWidth( binaryOutlineWidth * binaryOutlineShadowWidth );
           }
 
           localStorage->m_Actor->GetProperty()->SetLineWidth( binaryOutlineWidth );
         }
       }
       else
       {
         binaryOutline = false;
         this->ApplyLookuptable(renderer);
         MITK_WARN << "Type of all binary images should be (un)signed char. Outline does not work on other pixel types!";
       }
     }
     else //standard binary image
     {
       if(numberOfComponents != 1)
       {
         MITK_ERROR << "Rendering Error: Binary Images with more then 1 component are not supported!";
       }
     }
   }
 
   this->ApplyOpacity( renderer );
   this->ApplyRenderingMode(renderer);
 
   // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
   localStorage->m_Texture->MapColorScalarsThroughLookupTableOff();
 
   int displayedComponent = 0;
 
   if (datanode->GetIntProperty("Image.Displayed Component", displayedComponent, renderer) && numberOfComponents > 1)
   {
     localStorage->m_VectorComponentExtractor->SetComponents(displayedComponent);
     localStorage->m_VectorComponentExtractor->SetInputData(localStorage->m_ReslicedImage);
 
     localStorage->m_LevelWindowFilter->SetInputConnection(localStorage->m_VectorComponentExtractor->GetOutputPort(0));
   }
   else
   {
     //connect the input with the levelwindow filter
     localStorage->m_LevelWindowFilter->SetInputData(localStorage->m_ReslicedImage);
   }
 
   // check for texture interpolation property
   bool textureInterpolation = false;
   GetDataNode()->GetBoolProperty( "texture interpolation", textureInterpolation, renderer );
 
   //set the interpolation modus according to the property
   localStorage->m_Texture->SetInterpolate(textureInterpolation);
 
-//  bool doseProperty;
-//  if(datanode->GetBoolProperty("dose",doseProperty) && doseProperty)
-//  {
-//    // if the input is a dose file dont use the levelwindow filter because we need a float texture
-//    // and the levelwindow filter is casting to unsigned char
-//    localStorage->m_Texture->SetInput(localStorage->m_ReslicedImage);
-//  }
-//  else
-//  {
   // connect the texture with the output of the levelwindow filter
   localStorage->m_Texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
-//  }
 
   this->TransformActor( renderer );
 
   vtkActor* contourShadowActor = dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0));
 
   if(binary && binaryOutline) //connect the mapper with the polyData which contains the lines
   {
     //We need the contour for the binary outline property as actor
     localStorage->m_Mapper->SetInputData(localStorage->m_OutlinePolyData);
     localStorage->m_Actor->SetTexture(NULL); //no texture for contours
 
     bool binaryOutlineShadow( false );
     datanode->GetBoolProperty( "outline binary shadow", binaryOutlineShadow, renderer );
 
     if ( binaryOutlineShadow )
       contourShadowActor->SetVisibility( true );
     else
       contourShadowActor->SetVisibility( false );
   }
   else
   { //Connect the mapper with the input texture. This is the standard case.
     //setup the textured plane
     this->GeneratePlane( renderer, sliceBounds );
     //set the plane as input for the mapper
     localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
     //set the texture for the actor
 
     localStorage->m_Actor->SetTexture(localStorage->m_Texture);
     contourShadowActor->SetVisibility( false );
   }
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::ApplyLevelWindow(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage( renderer );
 
   LevelWindow levelWindow;
   this->GetDataNode()->GetLevelWindow( levelWindow, renderer, "levelwindow" );
   localStorage->m_LevelWindowFilter->GetLookupTable()->SetRange( levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound() );
 
   mitk::LevelWindow opacLevelWindow;
   if( this->GetDataNode()->GetLevelWindow( opacLevelWindow, renderer, "opaclevelwindow" ) )
   {
     //pass the opaque level window to the filter
     localStorage->m_LevelWindowFilter->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
     localStorage->m_LevelWindowFilter->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
   }
   else
   {
     //no opaque level window
     localStorage->m_LevelWindowFilter->SetMinOpacity(0.0);
     localStorage->m_LevelWindowFilter->SetMaxOpacity(255.0);
   }
 }
 
 void mitk::ImageVtkMapper2D::ApplyColor( mitk::BaseRenderer* renderer )
 {
   LocalStorage *localStorage = this->GetLocalStorage( renderer );
 
   float rgb[3]= { 1.0f, 1.0f, 1.0f };
 
   // check for color prop and use it for rendering if it exists
   // binary image hovering & binary image selection
   bool hover    = false;
   bool selected = false;
   GetDataNode()->GetBoolProperty("binaryimage.ishovering", hover, renderer);
   GetDataNode()->GetBoolProperty("selected", selected, renderer);
   if(hover && !selected)
   {
     mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
                                                                                 ("binaryimage.hoveringcolor", renderer));
     if(colorprop.IsNotNull())
     {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
     }
     else
     {
       GetDataNode()->GetColor( rgb, renderer, "color" );
     }
   }
   if(selected)
   {
     mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
                                                                                 ("binaryimage.selectedcolor", renderer));
     if(colorprop.IsNotNull()) {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
     }
     else
     {
       GetDataNode()->GetColor(rgb, renderer, "color");
     }
   }
   if(!hover && !selected)
   {
     GetDataNode()->GetColor( rgb, renderer, "color" );
   }
 
   double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
   dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0))->GetProperty()->SetColor(rgbConv);
   localStorage->m_Actor->GetProperty()->SetColor(rgbConv);
 
   if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
   {
     float rgb[3]= { 1.0f, 1.0f, 1.0f };
     mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
                                                                                 ("outline binary shadow color", renderer));
     if(colorprop.IsNotNull())
     {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
     }
     double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
     dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetColor(rgbConv);
   }
 }
 
-void mitk::ImageVtkMapper2D::ApplyShader( mitk::BaseRenderer* renderer)
-{
-  LocalStorage *localStorage = this->GetLocalStorage( renderer );
-
-  localStorage->m_Texture = vtkSmartPointer<vtkMitkShaderTexture>::New().GetPointer();
-
-  CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
-  itk::TimeStamp timestamp;
-  shaderRepo->ApplyProperties(this->GetDataNode(),localStorage->m_Actor,renderer,timestamp);
-}
-
 void mitk::ImageVtkMapper2D::ApplyOpacity( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = this->GetLocalStorage( renderer );
   float opacity = 1.0f;
   // check for opacity prop and use it for rendering if it exists
   GetDataNode()->GetOpacity( opacity, renderer, "opacity" );
   //set the opacity according to the properties
   localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
   if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
   {
     dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetOpacity(opacity);
   }
 }
 
 void mitk::ImageVtkMapper2D::ApplyRenderingMode( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
 
   bool binary = false;
   this->GetDataNode()->GetBoolProperty( "binary", binary, renderer );
   if(binary) // is it a binary image?
   {
     //for binary images, we always use our default LuT and map every value to (0,1)
     //the opacity of 0 will always be 0.0. We never a apply a LuT/TfF nor a level window.
     localStorage->m_LevelWindowFilter->SetLookupTable(localStorage->m_BinaryLookupTable);
   }
   else
   {
     //all other image types can make use of the rendering mode
     int renderingMode = mitk::RenderingModeProperty::LEVELWINDOW_COLOR;
     mitk::RenderingModeProperty::Pointer mode = dynamic_cast<mitk::RenderingModeProperty*>(this->GetDataNode()->GetProperty( "Image Rendering.Mode", renderer ));
     if(mode.IsNotNull())
     {
       renderingMode = mode->GetRenderingMode();
     }
     switch(renderingMode)
     {
     case mitk::RenderingModeProperty::LEVELWINDOW_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_Color";
       localStorage->m_LevelWindowFilter->SetLookupTable( localStorage->m_DefaultLookupTable );
       this->ApplyLevelWindow( renderer );
       break;
     case mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_LookupTable_Color";
       this->ApplyLookuptable( renderer );
       this->ApplyLevelWindow( renderer );
       break;
     case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_ColorTransferFunction_Color";
       this->ApplyColorTransferFunction( renderer );
       this->ApplyLevelWindow( renderer );
       break;
     case mitk::RenderingModeProperty::LOOKUPTABLE_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LookupTable_Color";
       this->ApplyLookuptable( renderer );
       break;
     case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = ColorTransferFunction_Color";
       this->ApplyColorTransferFunction( renderer );
       break;
-    case mitk::RenderingModeProperty::ISODOSESHADER_COLOR:
-      MITK_DEBUG << "'Image Rendering.Mode' = IsoDoseShader_Color";
-      localStorage->m_LevelWindowFilter->SetLookupTable(localStorage->m_DefaultLookupTable);
-      this->ApplyLevelWindow( renderer );
-//      this->ApplyShader( renderer );
-      break;
     default:
       MITK_ERROR << "No valid 'Image Rendering.Mode' set";
       break;
     }
   }
   //we apply color for all images (including binaries).
   this->ApplyColor( renderer );
 }
 
 void mitk::ImageVtkMapper2D::ApplyLookuptable( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
   vtkLookupTable* usedLookupTable = localStorage->m_ColorLookupTable;
 
   // If lookup table or transferfunction use is requested...
   mitk::LookupTableProperty::Pointer lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
 
   if( lookupTableProp.IsNotNull() ) // is a lookuptable set?
   {
     usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
   }
   else
   {
     //"Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'.
     //A default (rainbow) lookup table will be used.
     //Here have to do nothing. Warning for the user has been removed, due to unwanted console output
     //in every interation of the rendering.
   }
   localStorage->m_LevelWindowFilter->SetLookupTable(usedLookupTable);
 }
 
 void mitk::ImageVtkMapper2D::ApplyColorTransferFunction(mitk::BaseRenderer *renderer)
 {
   mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("Image Rendering.Transfer Function",renderer ));
 
   if( transferFunctionProp.IsNull() )
   {
     MITK_ERROR << "'Image Rendering.Mode'' was set to use a color transfer function but there is no property 'Image Rendering.Transfer Function'. Nothing will be done.";
     return;
   }
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
   //pass the transfer function to our level window filter
   localStorage->m_LevelWindowFilter->SetLookupTable(transferFunctionProp->GetValue()->GetColorTransferFunction());
 }
 
 void mitk::ImageVtkMapper2D::Update(mitk::BaseRenderer* renderer)
 {
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible )
   {
     return;
   }
 
   mitk::Image* data  = const_cast<mitk::Image *>( this->GetInput() );
   if ( data == NULL )
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
     || ( dataTimeGeometry->CountTimeSteps() == 0 )
     || ( !dataTimeGeometry->IsValidTimeStep( this->GetTimestep() ) ) )
   {
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   //check if something important has changed and we need to rerender
   if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
        || (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
        || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
        || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
        || (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
        || (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
   {
     this->GenerateDataForRenderer( renderer );
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
 
   // Properties common for both images and segmentations
   node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
   node->AddProperty( "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "outline width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
   node->AddProperty( "outline binary shadow", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "outline binary shadow color", ColorProperty::New(0.0,0.0,0.0), renderer, overwrite );
   node->AddProperty( "outline shadow width", mitk::FloatProperty::New( 1.5 ), renderer, overwrite );
   if(image->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
   else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
   node->AddProperty( "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) );  // set to user configurable default value (see global options)
   node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
   node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
 
-  CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
-  shaderRepo->AddDefaultProperties(node,renderer,overwrite);
-
   mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
   node->AddProperty( "Image Rendering.Mode", renderingModeProperty);
 
   // Set default grayscale look-up table
   mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
   mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
   mitkLutProp->SetLookupTable(mitkLut);
   node->SetProperty("LookupTable", mitkLutProp);
 
   std::string photometricInterpretation; // DICOM tag telling us how pixel values should be displayed
   if ( node->GetStringProperty( "dicom.pixel.PhotometricInterpretation", photometricInterpretation ) )
   {
     // modality provided by DICOM or other reader
     if ( photometricInterpretation.find("MONOCHROME1") != std::string::npos ) // meaning: display MINIMUM pixels as WHITE
     {
       // Set inverse grayscale look-up table
       mitkLut->SetType(mitk::LookupTable::INVERSE_GRAYSCALE);
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty("LookupTable", mitkLutProp);
     }
     // Otherwise do nothing - the default grayscale look-up table has already been set
     /*
     else
       if ( photometricInterpretation.find("MONOCHROME2") != std::string::npos ) // meaning: display MINIMUM pixels as BLACK
       {
         // apply default LUT (black to white)
         node->SetProperty( "color", mitk::ColorProperty::New( 1,1,1 ), renderer );
       }
     // PALETTE interpretation should be handled ok by RGB loading
     */
   }
 
   bool isBinaryImage(false);
   if ( ! node->GetBoolProperty("binary", isBinaryImage) )
   {
 
     // ok, property is not set, use heuristic to determine if this
     // is a binary image
     mitk::Image::Pointer centralSliceImage;
     ScalarType minValue = 0.0;
     ScalarType maxValue = 0.0;
     ScalarType min2ndValue = 0.0;
     ScalarType max2ndValue = 0.0;
     mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
 
     sliceSelector->SetInput(image);
     sliceSelector->SetSliceNr(image->GetDimension(2)/2);
     sliceSelector->SetTimeNr(image->GetDimension(3)/2);
     sliceSelector->SetChannelNr(image->GetDimension(4)/2);
     sliceSelector->Update();
     centralSliceImage = sliceSelector->GetOutput();
     if ( centralSliceImage.IsNotNull() && centralSliceImage->IsInitialized() )
     {
       minValue    = centralSliceImage->GetStatistics()->GetScalarValueMin();
       maxValue    = centralSliceImage->GetStatistics()->GetScalarValueMax();
       min2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMin();
       max2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMax();
     }
     if ((maxValue == min2ndValue && minValue == max2ndValue) || minValue == maxValue)
     {
       // centralSlice is strange, lets look at all data
       minValue    = image->GetStatistics()->GetScalarValueMin();
       maxValue    = image->GetStatistics()->GetScalarValueMaxNoRecompute();
       min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
       max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
     }
     isBinaryImage = ( maxValue == min2ndValue && minValue == max2ndValue );
   }
 
   // some more properties specific for a binary...
   if (isBinaryImage)
   {
     node->AddProperty( "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite );
     node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.selectedcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.selectedannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.hoveringcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.hoveringannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binary", mitk::BoolProperty::New( true ), renderer, overwrite );
     node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
   }
   else          //...or image type object
   {
     node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
     node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
     node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
     node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
 
     std::string className = image->GetNameOfClass();
 
     if (className != "TensorImage" && className != "QBallImage")
     {
       PixelType pixelType = image->GetPixelType();
       size_t numComponents = pixelType.GetNumberOfComponents();
 
       if ((pixelType.GetPixelTypeAsString() == "vector" && numComponents > 1) || numComponents == 2 || numComponents > 4)
         node->AddProperty("Image.Displayed Component", mitk::IntProperty::New(0), renderer, overwrite);
     }
   }
 
   if(image.IsNotNull() && image->IsInitialized())
   {
     if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
     {
       /* initialize level/window from DICOM tags */
       std::string sLevel;
       std::string sWindow;
       if ( image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
            && image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
       {
         float level = atof( sLevel.c_str() );
         float window = atof( sWindow.c_str() );
 
         mitk::LevelWindow contrast;
         std::string sSmallestPixelValueInSeries;
         std::string sLargestPixelValueInSeries;
 
         if ( image->GetPropertyList()->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
              && image->GetPropertyList()->GetStringProperty( "dicom.series.LargestPixelValueInSeries", sLargestPixelValueInSeries ) )
         {
           float smallestPixelValueInSeries = atof( sSmallestPixelValueInSeries.c_str() );
           float largestPixelValueInSeries = atof( sLargestPixelValueInSeries.c_str() );
           contrast.SetRangeMinMax( smallestPixelValueInSeries-1, largestPixelValueInSeries+1 ); // why not a little buffer?
           // might remedy some l/w widget challenges
         }
         else
         {
           contrast.SetAuto( static_cast<mitk::Image*>(node->GetData()), false, true ); // we need this as a fallback
         }
 
         contrast.SetLevelWindow( level, window, true );
         node->SetProperty( "levelwindow", LevelWindowProperty::New( contrast ), renderer );
       }
     }
     if(((overwrite) || (node->GetProperty("opaclevelwindow", renderer)==NULL))
        && (image->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA)
        && (image->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR) )
     {
       mitk::LevelWindow opaclevwin;
       opaclevwin.SetRangeMinMax(0,255);
       opaclevwin.SetWindowBounds(0,255);
       mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
       node->SetProperty( "opaclevelwindow", prop, renderer );
     }
   }
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::ImageVtkMapper2D::LocalStorage* mitk::ImageVtkMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 vtkSmartPointer<vtkPolyData> mitk::ImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer* renderer ){
-//  LocalStorage* localStorage = this->GetLocalStorage(renderer);
-
-//  vtkMarchingSquares* squares = vtkMarchingSquares::New();
-//  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
-
-//  float depth = CalculateLayerDepth(renderer);
-
-//  squares->SetInput(localStorage->m_ReslicedImage);
-//  squares->SetNumberOfContours(1);
-//  squares->SetValue(0,1);
-//  squares->Update();
-
-//  polyData = squares->GetOutput();
-
-//  vtkIdType numberOfPoints = polyData->GetNumberOfPoints();
-//  fstream f;
-//  f.open("mapper_neu.txt", ios::out);
-
-//  for(int i=0;i<numberOfPoints;i++)
-//  {
-//    double* x = polyData->GetPoint(i);
-//    x[2] = depth;
-//    f << "Point" << i << ": " << x[0] << ", " << x[1] << ", " << x[2] << endl;
-//  }
-
-//  polyData->BuildCells();
-//  polyData->BuildLinks();
-
-//  f.close();
-
   LocalStorage* localStorage = this->GetLocalStorage(renderer);
 
   //get the min and max index values of each direction
   int* extent = localStorage->m_ReslicedImage->GetExtent();
   int xMin = extent[0];
   int xMax = extent[1];
   int yMin = extent[2];
   int yMax = extent[3];
 
   int* dims = localStorage->m_ReslicedImage->GetDimensions(); //dimensions of the image
   int line = dims[0]; //how many pixels per line?
   int x = xMin; //pixel index x
   int y = yMin; //pixel index y
   char* currentPixel;
 
 
   //get the depth for each contour
   float depth = CalculateLayerDepth(renderer);
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); //the points to draw
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); //the lines to connect the points
 
   // We take the pointer to the first pixel of the image
   currentPixel = static_cast<char*>(localStorage->m_ReslicedImage->GetScalarPointer() );
 
   while (y <= yMax)
   {
     //if the current pixel value is set to something
     if ((currentPixel) && (*currentPixel != 0))
     {
       //check in which direction a line is necessary
       //a line is added if the neighbor of the current pixel has the value 0
       //and if the pixel is located at the edge of the image
 
       //if   vvvvv  not the first line vvvvv
       if (y > yMin && *(currentPixel-line) == 0)
       { //x direction - bottom edge of the pixel
         //add the 2 points
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         //add the line between both points
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  not the last line vvvvv
       if (y < yMax && *(currentPixel+line) == 0)
       { //x direction - top edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  not the first pixel vvvvv
       if ( (x > xMin || y > yMin) && *(currentPixel-1) == 0)
       { //y direction - left edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  not the last pixel vvvvv
       if ( (y < yMax || (x < xMax) ) && *(currentPixel+1) == 0)
       { //y direction - right edge of the pixel
         vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       /*  now consider pixels at the edge of the image  */
 
       //if   vvvvv  left edge of image vvvvv
       if (x == xMin)
       { //draw left edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  right edge of image vvvvv
       if (x == xMax)
       { //draw right edge of the pixel
         vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  bottom edge of image vvvvv
       if (y == yMin)
       { //draw bottom edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  top edge of image vvvvv
       if (y == yMax)
       { //draw top edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
     }//end if currentpixel is set
 
     x++;
 
     if (x > xMax)
     { //reached end of line
       x = xMin;
       y++;
     }
 
     // Increase the pointer-position to the next pixel.
     // This is safe, as the while-loop and the x-reset logic above makes
     // sure we do not exceed the bounds of the image
     currentPixel++;
   }//end of while
 
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   // Add the points to the dataset
   polyData->SetPoints(points);
   // Add the lines to the dataset
   polyData->SetLines(lines);
-
-  fstream f;
-  f.open("mapper_alt.txt", ios::out);
-
-  for(int i=0;i<polyData->GetNumberOfPoints();i++)
-  {
-    double x[3];
-    polyData->GetPoint(i,x);
-    f << "Point" << i << ": " << x[0] << ", " << x[1] << ", " << x[2] << endl;
-  }
-
-  f.close();
   return polyData;
 }
 
 void mitk::ImageVtkMapper2D::TransformActor(mitk::BaseRenderer* renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   //get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
   vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
   trans->SetMatrix(matrix);
   //transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
   localStorage->m_Actor->SetUserTransform(trans);
   //transform the origin to center based coordinates, because MITK is center based.
   localStorage->m_Actor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
 
   if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
   {
     vtkActor* secondaryActor = dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) );
     secondaryActor->SetUserTransform(trans);
     secondaryActor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
   }
 }
 
 bool mitk::ImageVtkMapper2D::RenderingGeometryIntersectsImage( const Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry )
 {
   // if either one of the two geometries is NULL we return true
   // for safety reasons
   if ( renderingGeometry == NULL || imageGeometry == NULL )
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance( imageGeometry->GetCornerPoint( 0 ) );
   for( int i=1; i<8; i++ )
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint( i );
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance( cornerPoint );
 
     // if it has not the same signing as the distance of the first point
     if ( initialDistance * distance < 0 )
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 mitk::ImageVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::ImageVtkMapper2D::LocalStorage::LocalStorage()
   : m_VectorComponentExtractor(vtkSmartPointer<vtkImageExtractComponents>::New())
 {
 
   m_LevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
 
   //Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
   m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_BinaryLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
   m_Reslicer = mitk::ExtractSliceFilter::New();
   m_TSFilter = vtkSmartPointer<vtkMitkThickSlicesFilter>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_ReslicedImage = vtkSmartPointer<vtkImageData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   //the following actions are always the same and thus can be performed
   //in the constructor for each image (i.e. the image-corresponding local storage)
   m_TSFilter->ReleaseDataFlagOn();
 
   mitk::LookupTable::Pointer mitkLUT = mitk::LookupTable::New();
   //built a default lookuptable
   mitkLUT->SetType(mitk::LookupTable::GRAYSCALE);
   m_DefaultLookupTable = mitkLUT->GetVtkLookupTable();
 
   mitkLUT->SetType(mitk::LookupTable::LEGACY_BINARY);
   m_BinaryLookupTable = mitkLUT->GetVtkLookupTable();
 
   // add a default rainbow lookup table for color mapping
   m_ColorLookupTable->SetRampToLinear();
   m_ColorLookupTable->SetHueRange(0.6667, 0.0);
   m_ColorLookupTable->SetTableRange(0.0, 20.0);
   m_ColorLookupTable->Build();
 
   //do not repeat the texture (the image)
   m_Texture->RepeatOff();
 
   //set the mapper for the actor
   m_Actor->SetMapper( m_Mapper );
 
   vtkSmartPointer<vtkActor> outlineShadowActor = vtkSmartPointer<vtkActor>::New();
   outlineShadowActor->SetMapper( m_Mapper );
 
   m_Actors->AddPart( outlineShadowActor );
   m_Actors->AddPart( m_Actor );
 }
diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.h b/Core/Code/Rendering/mitkImageVtkMapper2D.h
index 7086f1324a..1409106e72 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.h
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.h
@@ -1,322 +1,307 @@
 /*===================================================================
 
 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 MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E
 #define MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E
 
 //MITK
 #include <mitkCommon.h>
 
 //MITK Rendering
 #include "mitkBaseRenderer.h"
 #include "mitkVtkMapper.h"
 #include "mitkExtractSliceFilter.h"
 
 //VTK
 #include <vtkSmartPointer.h>
 #include <vtkPropAssembly.h>
 
-#include <vtkMarchingSquares.h>
-#include <vtkContourFilter.h>
-#include <vtkMarchingCubes.h>
-#include <mitkSurface.h>
-#include <mitkIOUtil.h>
-
-#include <mitkStandardFileLocations.h>
-#include <mitkCoreServices.h>
-#include <mitkShaderProperty.h>
-
-#include <fstream>
-
 class vtkActor;
 class vtkPolyDataMapper;
 class vtkPlaneSource;
 class vtkImageData;
 class vtkLookupTable;
 class vtkImageExtractComponents;
 class vtkImageReslice;
 class vtkImageChangeInformation;
 class vtkPoints;
 class vtkMitkThickSlicesFilter;
 class vtkPolyData;
 class vtkMitkApplyLevelWindowToRGBFilter;
 class vtkMitkLevelWindowFilter;
 
 namespace mitk {
 
 /** \brief Mapper to resample and display 2D slices of a 3D image.
  *
  * The following image gives a brief overview of the mapping and the involved parts.
  *
  * \image html imageVtkMapper2Darchitecture.png
  *
  * First, the image is resliced by means of vtkImageReslice. The volume image
  * serves as input to the mapper in addition to spatial placement of the slice and a few other
  * properties such as thick slices. This code was already present in the old version
  * (mitkImageMapperGL2D).
  *
  * Next, the obtained slice (m_ReslicedImage) is put into a vtkMitkLevelWindowFilter
  * and the scalar levelwindow, opacity levelwindow and optional clipping to
  * local image bounds are applied
  *
  * Next, the output of the vtkMitkLevelWindowFilter is used to create a texture
  * (m_Texture) and a plane onto which the texture is rendered (m_Plane). For
  * mapping purposes, a vtkPolyDataMapper (m_Mapper) is utilized. Orthographic
  * projection is applied to create the effect of a 2D image. The mapper and the
  * texture are assigned to the actor (m_Actor) which is passed to the VTK rendering
  * pipeline via the method GetVtkProp().
  *
  * In order to transform the textured plane to the correct position in space, the
  * same transformation as used for reslicing is applied to both the camera and the
  * vtkActor. All important steps are explained in more detail below. The resulting
  * 2D image (by reslicing the underlying 3D input image appropriately) can either
  * be directly rendered in a 2D view or just be calculated to be used later by another
  * rendering entity, e.g. in texture mapping in a 3D view.
  *
  * Properties that can be set for images and influence the imageMapper2D are:
  *
  *   - \b "opacity": (FloatProperty) Opacity of the image
  *   - \b "color": (ColorProperty) Color of the image
  *   - \b "LookupTable": (mitkLookupTableProperty) If this property is set,
  *          the default lookuptable will be ignored and the "LookupTable" value
  *          will be used instead.
  *   - \b "Image Rendering.Mode": This property decides which mode is used to render images. (E.g. if a lookup table or a transferfunction is applied). Detailed documentation about the modes can be found here: \link mitk::RenderingerModeProperty \endlink
  *   - \b "Image Rendering.Transfer Function": (mitkTransferFunctionProperty) If this
  *          property is set, a color transferfunction will be used to color the image.
  *   - \b "binary": (BoolProperty) is the image a binary image or not
  *   - \b "outline binary": (BoolProperty) show outline of the image or not
  *   - \b "texture interpolation": (BoolProperty) texture interpolation of the image
  *   - \b "reslice interpolation": (VtkResliceInterpolationProperty) reslice interpolation of the image
  *   - \b "in plane resample extent by geometry": (BoolProperty) Do it or not
  *   - \b "bounding box": (BoolProperty) Is the Bounding Box of the image shown or not
  *   - \b "layer": (IntProperty) Layer of the image
  *   - \b "volume annotation color": (ColorProperty) color of the volume annotation, TODO has to be reimplemented
  *   - \b "volume annotation unit": (StringProperty) annotation unit as string (does not implicit convert the unit!)
           unit is ml or cm3, TODO has to be reimplemented
 
  * The default properties are:
 
  *   - \b "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite )
  *   - \b "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite )
  *   - \b "binary", mitk::BoolProperty::New( true ), renderer, overwrite )
  *   - \b "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite )
  *   - \b "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) )
  *   - \b "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() )
  *   - \b "in plane resample extent by geometry", mitk::BoolProperty::New( false ) )
  *   - \b "bounding box", mitk::BoolProperty::New( false ) )
  *   - \b "layer", mitk::IntProperty::New(10), renderer, overwrite)
  *   - \b "Image Rendering.Transfer Function":  Default color transfer function for CTs
  *   - \b "LookupTable": Rainbow color.
 
  * If the modality-property is set for an image, the mapper uses modality-specific default properties,
  * e.g. color maps, if they are defined.
 
  * \ingroup Mapper
  */
 class MITK_CORE_EXPORT ImageVtkMapper2D : public VtkMapper
 {
 
 public:
   /** Standard class typedefs. */
   mitkClassMacro( ImageVtkMapper2D,VtkMapper );
 
   /** Method for creation through the object factory. */
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /** \brief Get the Image to map */
   const mitk::Image *GetInput(void);
 
   /** \brief Checks whether this mapper needs to update itself and generate
    * data. */
   virtual void Update(mitk::BaseRenderer * renderer);
 
   //### methods of MITK-VTK rendering pipeline
   virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
   //### end of methods of MITK-VTK rendering pipeline
 
 
   /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
   /**
      * To render transveral, coronal, and sagittal, the mapper is called three times.
      * For performance reasons, the corresponding data for each view is saved in the
      * internal helper class LocalStorage. This allows rendering n views with just
      * 1 mitkMapper using n vtkMapper.
      * */
   class MITK_CORE_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
   {
   public:
     /** \brief Actor of a 2D render window. */
     vtkSmartPointer<vtkActor> m_Actor;
 
     vtkSmartPointer<vtkPropAssembly> m_Actors;
     /** \brief Mapper of a 2D render window. */
     vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
     vtkSmartPointer<vtkImageExtractComponents> m_VectorComponentExtractor;
     /** \brief Current slice of a 2D render window.*/
     vtkSmartPointer<vtkImageData> m_ReslicedImage;
     /** \brief Empty vtkPolyData that is set when rendering geometry does not
       *   intersect the image geometry.
       *   \warning This member variable is set to NULL,
       *   if no image geometry is inside the plane geometry
       *   of the respective render window. Any user of this
       *   slice has to check whether it is set to NULL!
       */
     vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
     /** \brief Plane on which the slice is rendered as texture. */
     vtkSmartPointer<vtkPlaneSource> m_Plane;
     /** \brief The texture which is used to render the current slice. */
     vtkSmartPointer<vtkTexture> m_Texture;
     /** \brief The lookuptables for colors and level window */
     vtkSmartPointer<vtkLookupTable> m_DefaultLookupTable;
     vtkSmartPointer<vtkLookupTable> m_BinaryLookupTable;
     vtkSmartPointer<vtkLookupTable> m_ColorLookupTable;
     /** \brief The actual reslicer (one per renderer) */
     mitk::ExtractSliceFilter::Pointer m_Reslicer;
     /** \brief Filter for thick slices */
     vtkSmartPointer<vtkMitkThickSlicesFilter> m_TSFilter;
     /** \brief PolyData object containg all lines/points needed for outlining the contour.
           This container is used to save a computed contour for the next rendering execution.
           For instance, if you zoom or pann, there is no need to recompute the contour. */
     vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
 
     /** \brief Timestamp of last update of stored data. */
     itk::TimeStamp m_LastUpdateTime;
 
     /** \brief mmPerPixel relation between pixel and mm. (World spacing).*/
     mitk::ScalarType* m_mmPerPixel;
 
     /** \brief This filter is used to apply the level window to Grayvalue and RBG(A) images. */
     vtkSmartPointer<vtkMitkLevelWindowFilter> m_LevelWindowFilter;
 
     /** \brief Default constructor of the local storage. */
     LocalStorage();
     /** \brief Default deconstructor of the local storage. */
     ~LocalStorage();
   };
 
   /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
   mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
   /** \brief Get the LocalStorage corresponding to the current renderer. */
   LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
 
   /** \brief Set the default properties for general image rendering. */
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
   /** \brief This method switches between different rendering modes (e.g. use a lookup table or a transfer function).
    * Detailed documentation about the modes can be found here: \link mitk::RenderingerModeProperty \endlink
    */
   void ApplyRenderingMode(mitk::BaseRenderer *renderer);
 
 protected:
   /** \brief Transforms the actor to the actual position in 3D.
     *   \param renderer The current renderer corresponding to the render window.
     */
   void TransformActor(mitk::BaseRenderer* renderer);
 
   /** \brief Generates a plane according to the size of the resliced image in milimeters.
     *
     * \image html texturedPlane.png
     *
     * In VTK a vtkPlaneSource is defined through three points. The origin and two
     * points defining the axes of the plane (see VTK documentation). The origin is
     * set to (xMin; yMin; Z), where xMin and yMin are the minimal bounds of the
     * resliced image in space. Z is relevant for blending and the layer property.
     * The center of the plane (C) is also the center of the view plane (cf. the image above).
     *
     * \note For the standard MITK view with three 2D render windows showing three
     * different slices, three such planes are generated. All these planes are generated
     * in the XY-plane (even if they depict a YZ-slice of the volume).
     *
     */
   void GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6]);
 
   /** \brief Generates a vtkPolyData object containing the outline of a given binary slice.
       \param renderer: Pointer to the renderer containing the needed information
       \note This code is based on code from the iil library.
       */
   vtkSmartPointer<vtkPolyData> CreateOutlinePolyData(mitk::BaseRenderer* renderer);
 
   /** Default constructor */
   ImageVtkMapper2D();
   /** Default deconstructor */
   virtual ~ImageVtkMapper2D();
 
   /** \brief Does the actual resampling, without rendering the image yet.
     * All the data is generated inside this method. The vtkProp (or Actor)
     * is filled with content (i.e. the resliced image).
     *
     * After generation, a 4x4 transformation matrix(t) of the current slice is obtained
     * from the vtkResliceImage object via GetReslicesAxis(). This matrix is
     * applied to each textured plane (actor->SetUserTransform(t)) to transform everything
     * to the actual 3D position (cf. the following image).
     *
     * \image html cameraPositioning3D.png
     *
     */
   virtual void GenerateDataForRenderer(mitk::BaseRenderer *renderer);
 
   /** \brief This method uses the vtkCamera clipping range and the layer property
     * to calcualte the depth of the object (e.g. image or contour). The depth is used
     * to keep the correct order for the final VTK rendering.*/
   float CalculateLayerDepth(mitk::BaseRenderer* renderer);
 
   /** \brief This method applies (or modifies) the lookuptable for all types of images.
    * \warning To use the lookup table, the property 'Lookup Table' must be set and a 'Image Rendering.Mode'
    * which uses the lookup table must be set.
 */
   void ApplyLookuptable(mitk::BaseRenderer* renderer);
 
   /** \brief This method applies a color transfer function.
    * Internally, a vtkColorTransferFunction is used. This is usefull for coloring continous
    * images (e.g. float)
    * \warning To use the color transfer function, the property 'Image Rendering.Transfer Function' must be set and a 'Image Rendering.Mode' which uses the color transfer function must be set.
 */
   void ApplyColorTransferFunction(mitk::BaseRenderer* renderer);
 
   /**
    * @brief ApplyLevelWindow Apply the level window for the given renderer.
    * \warning To use the level window, the property 'LevelWindow' must be set and a 'Image Rendering.Mode' which uses the level window must be set.
    * @param renderer Level window for which renderer?
    */
   void ApplyLevelWindow(mitk::BaseRenderer* renderer);
 
   /** \brief Set the color of the image/polydata */
   void ApplyColor( mitk::BaseRenderer* renderer );
 
-  /** \brief Set the shader of the image/polydata */
-  void ApplyShader( mitk::BaseRenderer* renderer );
-
   /** \brief Set the opacity of the actor. */
   void ApplyOpacity( mitk::BaseRenderer* renderer );
 
   /**
     * \brief Calculates whether the given rendering geometry intersects the
     * given SlicedGeometry3D.
     *
     * This method checks if the given Geometry2D intersects the given
     * SlicedGeometry3D. It calculates the distance of the Geometry2D to all
     * 8 cornerpoints of the SlicedGeometry3D. If all distances have the same
     * sign (all positive or all negative) there is no intersection.
     * If the distances have different sign, there is an intersection.
     **/
   bool RenderingGeometryIntersectsImage( const Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry );
 };
 
 } // namespace mitk
 
 #endif /* MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E */
diff --git a/Core/Code/Rendering/vtkMitkShaderTexture.cpp b/Core/Code/Rendering/vtkMitkShaderTexture.cpp
deleted file mode 100644
index 39a0dc8387..0000000000
--- a/Core/Code/Rendering/vtkMitkShaderTexture.cpp
+++ /dev/null
@@ -1,514 +0,0 @@
-/*===================================================================
-
-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 "vtkMitkShaderTexture.h"
-
-#include "vtkHomogeneousTransform.h"
-#include "vtkImageData.h"
-#include "vtkLookupTable.h"
-#include "vtkObjectFactory.h"
-#include "vtkOpenGLRenderer.h"
-#include "vtkPointData.h"
-#include "vtkRenderWindow.h"
-#include "vtkOpenGLExtensionManager.h"
-#include "vtkOpenGLRenderWindow.h"
-#include "vtkTransform.h"
-#include "vtkPixelBufferObject.h"
-#include "vtkOpenGL.h"
-#include "vtkUnsignedShortArray.h"
-#include "vtkFloatArray.h"
-#include "vtkgl.h" // vtkgl namespace
-//#include "GL/glext.h"
-
-#include <math.h>
-
-#ifndef VTK_IMPLEMENT_MESA_CXX
-vtkStandardNewMacro(vtkMitkShaderTexture);
-#endif
-
-void vtkMitkShaderTexture::SetLevelWindow(float lower, float upper)
-{
-  this->LevelWindowEnabled = true;
-  this->LevelWindowLower = lower;
-  this->LevelWindowUpper = upper;
-  if(this->Index)
-  {
-    glBindTexture(GL_TEXTURE_2D, this->Index);
-#ifdef MES_MOBILE_BUILD
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LW_LOWER, this->LevelWindowLower);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LW_UPPER, this->LevelWindowUpper);
-#endif
-  }
-}
-
-
-// ----------------------------------------------------------------------------
-// Initializes an instance, generates a unique index.
-vtkMitkShaderTexture::vtkMitkShaderTexture()
-{
-  this->Index = 0;
-  this->RenderWindow = 0;
-  this->LevelWindowEnabled = false;
-  this->LevelWindowLower = 0.0f;
-  this->LevelWindowUpper = 0.0f;
-
-  this->Format16BIT = false;
-
-  MapColorScalarsThroughLookupTable = 0;
-}
-
-// ----------------------------------------------------------------------------
-vtkMitkShaderTexture::~vtkMitkShaderTexture()
-{
-  if (this->RenderWindow)
-  {
-    this->ReleaseGraphicsResources(this->RenderWindow);
-  }
-  this->RenderWindow = NULL;
-}
-
-// ----------------------------------------------------------------------------
-void vtkMitkShaderTexture::Initialize(vtkRenderer * vtkNotUsed(ren))
-{
-}
-
-// ----------------------------------------------------------------------------
-// Release the graphics resources used by this texture.
-void vtkMitkShaderTexture::ReleaseGraphicsResources(vtkWindow *renWin)
-{
-  if (this->Index && renWin && renWin->GetMapped())
-  {
-    static_cast<vtkRenderWindow *>(renWin)->MakeCurrent();
-
-    // free any textures
-    if (glIsTexture(static_cast<GLuint>(this->Index)))
-    {
-      GLuint tempIndex;
-      tempIndex = this->Index;
-      // NOTE: Sun's OpenGL seems to require disabling of texture before delete
-      glDisable(GL_TEXTURE_2D);
-      glDeleteTextures(1, &tempIndex);
-    }
-  }
-  this->Index = 0;
-  this->RenderWindow = NULL;
-  this->Modified();
-}
-
-// ----------------------------------------------------------------------------
-// Implement base class method.
-void vtkMitkShaderTexture::Load(vtkRenderer *ren)
-{
-  GLenum format = GL_LUMINANCE;
-  vtkImageData *input = this->GetInput();
-
-  this->Initialize(ren);
-
-  // Need to reload the texture.
-  // There used to be a check on the render window's mtime, but
-  // this is too broad of a check (e.g. it would cause all textures
-  // to load when only the desired update rate changed).
-  // If a better check is required, check something more specific,
-  // like the graphics context.
-//  vtkOpenGLRenderWindow* renWin =
-//  static_cast<vtkOpenGLRenderWindow*>(ren->GetRenderWindow());
-
-  if(this->BlendingMode != VTK_TEXTURE_BLENDING_MODE_NONE
-     && vtkgl::ActiveTexture)
-  {
-    glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, vtkgl::COMBINE);
-
-    switch(this->BlendingMode)
-    {
-      case VTK_TEXTURE_BLENDING_MODE_REPLACE:
-      {
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, GL_REPLACE);
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, GL_REPLACE);
-        break;
-      }
-      case VTK_TEXTURE_BLENDING_MODE_MODULATE:
-      {
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, GL_MODULATE);
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, GL_MODULATE);
-        break;
-      }
-      case VTK_TEXTURE_BLENDING_MODE_ADD:
-      {
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, GL_ADD);
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, GL_ADD);
-        break;
-      }
-      case VTK_TEXTURE_BLENDING_MODE_ADD_SIGNED:
-      {
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, vtkgl::ADD_SIGNED);
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, vtkgl::ADD_SIGNED);
-        break;
-      }
-      case VTK_TEXTURE_BLENDING_MODE_INTERPOLATE:
-      {
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, vtkgl::INTERPOLATE);
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, vtkgl::INTERPOLATE);
-        break;
-      }
-      case VTK_TEXTURE_BLENDING_MODE_SUBTRACT:
-      {
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, vtkgl::SUBTRACT);
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, vtkgl::SUBTRACT);
-        break;
-      }
-      default:
-      {
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, GL_ADD);
-        glTexEnvf (GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, GL_ADD);
-      }
-    }
-  }
-
-  if (this->GetMTime() > this->LoadTime.GetMTime() ||
-      input->GetMTime() > this->LoadTime.GetMTime() ||
-      (this->GetLookupTable() && this->GetLookupTable()->GetMTime () > this->LoadTime.GetMTime()) )
-  {
-    int size[3];
-    vtkDataArray *scalars;
-    float *floatPtr;
-    float *floatData=NULL;
-    int xsize, ysize;
-    GLuint tempIndex=0;
-
-    scalars = this->GetInputArrayToProcess(0, input);
-
-    if (!scalars)
-    {
-      vtkErrorMacro(<< "No scalar values found for texture input!");
-      return;
-    }
-
-    input->GetDimensions(size);
-
-    if (input->GetNumberOfCells() == scalars->GetNumberOfTuples())
-    {
-      // we are using cell scalars. Adjust image size for cells.
-      for (int kk=0; kk < 3; kk++)
-      {
-        if (size[kk]>1)
-        {
-          size[kk]--;
-        }
-      }
-    }
-
-    // we only support 2d texture maps right now so one of the three sizes must be 1,
-    // but it could be any of them, so lets find it
-    if (size[0] == 1)
-    {
-      xsize = size[1];
-      ysize = size[2];
-    }
-    else
-    {
-      xsize = size[0];
-      if (size[1] == 1)
-      {
-        ysize = size[2];
-      }
-      else
-      {
-        ysize = size[1];
-        if (size[2] != 1)
-        {
-          vtkErrorMacro(<< "3D texture maps currently are not supported!");
-          return;
-        }
-      }
-    }
-
-//    numChannels = scalars->GetNumberOfComponents();
-
-    this->Interpolate = 1;
-
-    if (scalars->GetDataType() == VTK_FLOAT)
-    {
-      floatData = new float[xsize*ysize];
-      floatPtr = reinterpret_cast<float *>(static_cast<vtkFloatArray *>(scalars)->GetPointer(0));
-      floatData = floatPtr;
-    }
-
-    // -- decide whether the texture needs to be resampled --
-
-    GLint maxDimGL;
-    glGetIntegerv(GL_MAX_TEXTURE_SIZE,&maxDimGL);
-    // if larger than permitted by the graphics library then must resample
-    bool resampleNeeded=xsize > maxDimGL || ysize > maxDimGL;
-    if(resampleNeeded)
-    {
-      vtkDebugMacro( "Texture too big for gl, maximum is " << maxDimGL);
-    }
-
-    // free any old display lists (from the old context)
-    this->RenderWindow = ren->GetRenderWindow();
-
-    // make the new context current before we mess with opengl
-    this->RenderWindow->MakeCurrent();
-
-    // define a display list for this texture
-    // get a unique display list id
-
-    if(!this->Index)
-    {
-      glGenTextures(1, &tempIndex);
-      this->Index = static_cast<long>(tempIndex);
-    }
-    glBindTexture(GL_TEXTURE_2D, this->Index);
-
-    if (this->Interpolate)
-    {
-      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                      GL_LINEAR);
-      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
-                      GL_LINEAR );
-    }
-    else
-    {
-      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
-      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
-    }
-    if (this->Repeat)
-    {
-      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     GL_REPEAT );
-      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     GL_REPEAT );
-    }
-    else
-    {
-        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
-                        vtkgl::CLAMP_TO_EDGE );
-        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
-                        vtkgl::CLAMP_TO_EDGE );
-    }
-
-//    int internalFormat = GL_LUMINANCE32F_ARB;
-    int internalFormat = 0;
-    format = GL_LUMINANCE;
-
-    glTexImage2D( GL_TEXTURE_2D, 0 , internalFormat,
-                  xsize, ysize, 0, format,
-                  GL_FLOAT,
-                  static_cast<const GLvoid *>(floatData) );
-
-    this->Format16BIT = false;
-
-
-    // modify the load time to the current time
-    this->LoadTime.Modified();
-
-    // free memory
-    if (floatData != floatPtr)
-    {
-      delete [] floatData;
-    }
-  }
-
-  // execute the display list that uses creates the texture
-  glBindTexture(GL_TEXTURE_2D, this->Index);
-
-  if (this->LevelWindowEnabled)
-  {
-#ifdef MES_MOBILE_BUILD
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LW_LOWER, this->LevelWindowLower);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LW_UPPER, this->LevelWindowUpper);
-#endif
-  }
-
-  // don't accept fragments if they have zero opacity. this will stop the
-  // zbuffer from be blocked by totally transparent texture fragments.
-  glAlphaFunc (GL_GREATER, static_cast<GLclampf>(0));
-  glEnable (GL_ALPHA_TEST);
-
-  if (this->PremultipliedAlpha)
-  {
-    // save the blend function.
-    glPushAttrib(GL_COLOR_BUFFER_BIT);
-
-    // make the blend function correct for textures premultiplied by alpha.
-    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-  }
-
-  // now bind it
-  glEnable(GL_TEXTURE_2D);
-
-  // clear any texture transform
-  glMatrixMode(GL_TEXTURE);
-  glLoadIdentity();
-
-  // build transformation
-  if (this->Transform)
-  {
-    double *mat = this->Transform->GetMatrix()->Element[0];
-    double mat2[16];
-    mat2[0] = mat[0];
-    mat2[1] = mat[4];
-    mat2[2] = mat[8];
-    mat2[3] = mat[12];
-    mat2[4] = mat[1];
-    mat2[5] = mat[5];
-    mat2[6] = mat[9];
-    mat2[7] = mat[13];
-    mat2[8] = mat[2];
-    mat2[9] = mat[6];
-    mat2[10] = mat[10];
-    mat2[11] = mat[14];
-    mat2[12] = mat[3];
-    mat2[13] = mat[7];
-    mat2[14] = mat[11];
-    mat2[15] = mat[15];
-
-    // insert texture transformation
-    glMultMatrixd(mat2);
-  }
-  glMatrixMode(GL_MODELVIEW);
-
-}
-
-// ----------------------------------------------------------------------------
-void vtkMitkShaderTexture::PostRender(vtkRenderer *vtkNotUsed(ren))
-{
-  if (this->GetInput() && this->PremultipliedAlpha)
-  {
-    // restore the blend function
-    glPopAttrib();
-  }
-}
-
-// ----------------------------------------------------------------------------
-static int FindPowerOfTwo(int i)
-{
-  int size;
-
-  for ( i--, size=1; i > 0; size*=2 )
-  {
-    i /= 2;
-  }
-
-  // [these lines added by Tim Hutton (implementing Joris Vanden Wyngaerd's
-  // suggestions)]
-  // limit the size of the texture to the maximum allowed by OpenGL
-  // (slightly more graceful than texture failing but not ideal)
-  GLint maxDimGL;
-  glGetIntegerv(GL_MAX_TEXTURE_SIZE,&maxDimGL);
-  if ( size > maxDimGL )
-  {
-    size = maxDimGL ;
-  }
-  // end of Tim's additions
-
-  return size;
-}
-
-// ----------------------------------------------------------------------------
-// Creates resampled unsigned char texture map that is a power of two in both
-// x and y.
-template <typename T>
-T *vtkMitkShaderTexture::ResampleToPowerOfTwo(int &xs,
-                                             int &ys,
-                                             T *dptr,
-                                             int numChannels)
-{
-  T *tptr, *p, *p1, *p2, *p3, *p4;
-  int xsize, ysize, i, j, k, jOffset, iIdx, jIdx;
-  double pcoords[3], hx, hy, rm, sm, w0, w1, w2, w3;
-
-  xsize = FindPowerOfTwo(xs);
-  ysize = FindPowerOfTwo(ys);
-  if (this->RestrictPowerOf2ImageSmaller)
-  {
-    if (xsize > xs)
-    {
-      xsize /= 2;
-    }
-    if (ysize > ys)
-    {
-      ysize /= 2;
-    }
-  }
-  hx = xsize > 1 ? (xs - 1.0) / (xsize - 1.0) : 0;
-  hy = ysize > 1 ? (ys - 1.0) / (ysize - 1.0) : 0;
-
-  tptr = p = new T[xsize*ysize*numChannels];
-
-  // Resample from the previous image. Compute parametric coordinates and
-  // interpolate
-  for (j=0; j < ysize; j++)
-  {
-    pcoords[1] = j*hy;
-
-    jIdx = static_cast<int>(pcoords[1]);
-    if ( jIdx >= (ys-1) ) //make sure to interpolate correctly at edge
-    {
-      jIdx = ys - 2;
-      pcoords[1] = 1.0;
-    }
-    else
-    {
-      pcoords[1] = pcoords[1] - jIdx;
-    }
-    jOffset = jIdx*xs;
-    sm = 1.0 - pcoords[1];
-
-    for (i=0; i < xsize; i++)
-    {
-      pcoords[0] = i*hx;
-      iIdx = static_cast<int>(pcoords[0]);
-      if ( iIdx >= (xs-1) )
-      {
-        iIdx = xs - 2;
-        pcoords[0] = 1.0;
-      }
-      else
-      {
-        pcoords[0] = pcoords[0] - iIdx;
-      }
-      rm = 1.0 - pcoords[0];
-
-      // Get pointers to 4 surrounding pixels
-      p1 = dptr + numChannels*(iIdx + jOffset);
-      p2 = p1 + numChannels;
-      p3 = p1 + numChannels*xs;
-      p4 = p3 + numChannels;
-
-      // Compute interpolation weights interpolate components
-      w0 = rm*sm;
-      w1 = pcoords[0]*sm;
-      w2 = rm*pcoords[1];
-      w3 = pcoords[0]*pcoords[1];
-      for (k=0; k < numChannels; k++)
-      {
-        *p++ = static_cast<T>(p1[k]*w0 + p2[k]*w1 + p3[k]*w2
-                              + p4[k]*w3);
-      }
-    }
-  }
-
-  xs = xsize;
-  ys = ysize;
-
-  return tptr;
-}
-
-// ----------------------------------------------------------------------------
-void vtkMitkShaderTexture::PrintSelf(ostream& os, vtkIndent indent)
-{
-  this->Superclass::PrintSelf(os,indent);
-  os << indent << "Index: " << this->Index << endl;
-}
diff --git a/Core/Code/Rendering/vtkMitkShaderTexture.h b/Core/Code/Rendering/vtkMitkShaderTexture.h
deleted file mode 100644
index 4c9c84f8f4..0000000000
--- a/Core/Code/Rendering/vtkMitkShaderTexture.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*===================================================================
-
-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.
-
-===================================================================*/
-
-// .NAME vtkMitkShaderTexture - OpenGL texture map
-// .SECTION Description
-// vtkMitkShaderTexture is a concrete implementation of the abstract class
-// vtkTexture. vtkMitkShaderTexture interfaces to the OpenGL rendering library.
-
-#ifndef __vtkMesOpenGLTexture_h
-#define __vtkMesOpenGLTexture_h
-
-#include "vtkTexture.h"
-//BTX
-#include "vtkWeakPointer.h" // needed for vtkWeakPointer.
-//ETX
-
-class vtkWindow;
-class vtkOpenGLRenderer;
-class vtkRenderWindow;
-class vtkPixelBufferObject;
-
-class vtkMitkShaderTexture : public vtkTexture
-{
-public:
-  static vtkMitkShaderTexture *New();
-  vtkTypeMacro(vtkMitkShaderTexture,vtkTexture);
-  virtual void PrintSelf(ostream& os, vtkIndent indent);
-
-  // Description:
-  // Implement base class method.
-  void Load(vtkRenderer *ren);
-
-  // Descsription:
-  // Clean up after the rendering is complete.
-  virtual void PostRender(vtkRenderer *ren);
-
-  // Description:
-  // Release any graphics resources that are being consumed by this texture.
-  // The parameter window could be used to determine which graphic
-  // resources to release. Using the same texture object in multiple
-  // render windows is NOT currently supported.
-  void ReleaseGraphicsResources(vtkWindow *);
-
-  void SetLevelWindow(float lower, float upper);
-
-  float GetLevelWindowLower() const { return LevelWindowLower; }
-  float GetLevelWindowUpper() const { return LevelWindowUpper; }
-  bool Is16Bit() const { return Format16BIT; }
-  // Description:
-  // Get the openGL texture name to which this texture is bound.
-  // This is available only if GL version >= 1.1
-  vtkGetMacro(Index, long);
-//BTX
-protected:
-  vtkMitkShaderTexture();
-  ~vtkMitkShaderTexture();
-
-  template <typename T>
-  T *ResampleToPowerOfTwo(int &xsize, int &ysize, T *dptr, int numChannels);
-
-  vtkTimeStamp   LoadTime;
-  unsigned int Index; // actually GLuint
-  vtkWeakPointer<vtkRenderWindow> RenderWindow;   // RenderWindow used for previous render
-
-  bool Format16BIT;
-  bool LevelWindowEnabled;
-  float LevelWindowLower;
-  float LevelWindowUpper;
-
-private:
-  vtkMitkShaderTexture(const vtkMitkShaderTexture&);  // Not implemented.
-  void operator=(const vtkMitkShaderTexture&);  // Not implemented.
-
-  // Description:
-  // Handle loading in extension support
-  virtual void Initialize(vtkRenderer * ren);
-
-//ETX
-};
-
-#endif
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index f340568c70..bcc2ab8d80 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,408 +1,405 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/mitkInstantiateAccessFunctions.h
   Algorithms/mitkPixelTypeList.h
   Algorithms/mitkPPArithmeticDec.h
   Algorithms/mitkPPArgCount.h
   Algorithms/mitkPPCat.h
   Algorithms/mitkPPConfig.h
   Algorithms/mitkPPControlExprIIf.h
   Algorithms/mitkPPControlIf.h
   Algorithms/mitkPPControlIIf.h
   Algorithms/mitkPPDebugError.h
   Algorithms/mitkPPDetailAutoRec.h
   Algorithms/mitkPPDetailDMCAutoRec.h
   Algorithms/mitkPPExpand.h
   Algorithms/mitkPPFacilitiesEmpty.h
   Algorithms/mitkPPFacilitiesExpand.h
   Algorithms/mitkPPLogicalBool.h
   Algorithms/mitkPPRepetitionDetailDMCFor.h
   Algorithms/mitkPPRepetitionDetailEDGFor.h
   Algorithms/mitkPPRepetitionDetailFor.h
   Algorithms/mitkPPRepetitionDetailMSVCFor.h
   Algorithms/mitkPPRepetitionFor.h
   Algorithms/mitkPPSeqElem.h
   Algorithms/mitkPPSeqForEach.h
   Algorithms/mitkPPSeqForEachProduct.h
   Algorithms/mitkPPSeq.h
   Algorithms/mitkPPSeqEnum.h
   Algorithms/mitkPPSeqSize.h
   Algorithms/mitkPPSeqToTuple.h
   Algorithms/mitkPPStringize.h
   Algorithms/mitkPPTupleEat.h
   Algorithms/mitkPPTupleElem.h
   Algorithms/mitkPPTupleRem.h
   Algorithms/mitkClippedSurfaceBoundsCalculator.h
   Algorithms/mitkExtractSliceFilter.h
   Algorithms/mitkConvert2Dto3DImageFilter.h
   Algorithms/mitkPlaneClipping.h
 
   Common/mitkCommon.h
   Common/mitkExceptionMacro.h
 
   DataManagement/mitkProportionalTimeGeometry.h
   DataManagement/mitkTimeGeometry.h
   DataManagement/mitkImageAccessByItk.h
   DataManagement/mitkImageCast.h
   DataManagement/mitkImagePixelAccessor.h
   DataManagement/mitkImagePixelReadAccessor.h
   DataManagement/mitkImagePixelWriteAccessor.h
   DataManagement/mitkImageReadAccessor.h
   DataManagement/mitkImageWriteAccessor.h
   DataManagement/mitkITKImageImport.h
   DataManagement/mitkITKImageImport.txx
   DataManagement/mitkImageToItk.h
   DataManagement/mitkShaderProperty.h
   DataManagement/mitkImageToItk.txx
   DataManagement/mitkTimeSlicedGeometry.h # Deprecated, empty for compatibilty reasons.
   DataManagement/mitkPropertyListReplacedObserver.cpp
 
   Interactions/mitkEventMapperAddOn.h
 
   Interfaces/mitkIDataNodeReader.h
 
   Rendering/mitkLocalStorageHandler.h
   Rendering/Colortables/HotIron.h
   Rendering/Colortables/Jet.h
   Rendering/Colortables/PET20.h
   Rendering/Colortables/PETColor.h
 
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCoreActivator.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
 # DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataNodeFactory.cpp
 # DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkGeometry2D.cpp
   DataManagement/mitkGeometry2DData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkVector.cpp
 
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkShaderProperty.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
 # Interactions/mitkDisplayVectorInteractorLevelWindow.cpp # legacy, prob even now unneeded
 # Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMoveBaseDataInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkXML2EventParser.cpp
 
   Interfaces/mitkInteractionEventObserver.cpp
   Interfaces/mitkIShaderRepository.cpp
   Interfaces/mitkIPropertyAliases.cpp
   Interfaces/mitkIPropertyDescriptions.cpp
   Interfaces/mitkIPropertyExtensions.cpp
   Interfaces/mitkIPropertyFilters.cpp
   Interfaces/mitkIPersistenceService.cpp
 
   IO/mitkBaseDataIOFactory.cpp
   IO/mitkCoreDataNodeReader.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkDicomSR_LoadDICOMScalar.cpp
   IO/mitkDicomSR_LoadDICOMScalar4D.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel4D.cpp
   IO/mitkDicomSR_ImageBlockDescriptor.cpp
   IO/mitkDicomSR_GantryTiltInformation.cpp
   IO/mitkDicomSR_SliceGroupingResult.cpp
 
   IO/mitkFileReader.cpp
   IO/mitkFileSeriesReader.cpp
   IO/mitkFileWriter.cpp
 # IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkImageWriter.cpp
   IO/mitkImageWriterFactory.cpp
   IO/mitkItkImageFileIOFactory.cpp
   IO/mitkItkImageFileReader.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkItkPictureWrite.cpp
   IO/mitkIOUtil.cpp
   IO/mitkLookupTableProperty.cpp
   IO/mitkOperation.cpp
 # IO/mitkPicFileIOFactory.cpp
 # IO/mitkPicFileReader.cpp
 # IO/mitkPicFileWriter.cpp
 # IO/mitkPicHelper.cpp
 # IO/mitkPicVolumeTimeSeriesIOFactory.cpp
 # IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetIOFactory.cpp
   IO/mitkPointSetReader.cpp
   IO/mitkPointSetWriter.cpp
   IO/mitkPointSetWriterFactory.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSTLFileIOFactory.cpp
   IO/mitkSTLFileReader.cpp
   IO/mitkSurfaceVtkWriter.cpp
   IO/mitkSurfaceVtkWriterFactory.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkVtiFileIOFactory.cpp
   IO/mitkVtiFileReader.cpp
   IO/mitkVtkImageIOFactory.cpp
   IO/mitkVtkImageReader.cpp
   IO/mitkVtkSurfaceIOFactory.cpp
   IO/mitkVtkSurfaceReader.cpp
   IO/vtkPointSetXMLParser.cpp
   IO/mitkLog.cpp
 
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkGeometry2DDataMapper2D.cpp
   Rendering/mitkGeometry2DDataVtkMapper3D.cpp
   Rendering/mitkGLMapper.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkPolyDataGLMapper2D.cpp
   Rendering/mitkSurfaceGLMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
-
-  Rendering/vtkMitkShaderTexture.cpp
-
   Rendering/mitkOverlay.cpp
   Rendering/mitkVtkOverlay.cpp
   Rendering/mitkVtkOverlay2D.cpp
   Rendering/mitkVtkOverlay3D.cpp
   Rendering/mitkOverlayManager.cpp
   Rendering/mitkAbstractOverlayLayouter.cpp
 
   Rendering/mitkTextOverlay2D.cpp
   Rendering/mitkTextOverlay3D.cpp
   Rendering/mitkLabelOverlay3D.cpp
   Rendering/mitkOverlay2DLayouter.cpp
   Rendering/mitkScaleLegendOverlay
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
   Common/mitkCoreServices.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 )
diff --git a/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp
index b1f75b335d..073936ea1e 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp
@@ -1,329 +1,329 @@
 /*===================================================================
 
 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 "mitkContourModelSetGLMapper2D.h"
 
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkContourModelSet.h"
 #include <vtkLinearTransform.h>
 
 #include "mitkGL.h"
 
 mitk::ContourModelGLMapper2DBase::ContourModelGLMapper2DBase()
 {
 }
 
 mitk::ContourModelGLMapper2DBase::~ContourModelGLMapper2DBase()
 {
 }
 
 
 void mitk::ContourModelGLMapper2DBase::DrawContour(mitk::ContourModel* renderingContour, mitk::BaseRenderer* renderer)
 {
   if(!renderingContour) return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   renderingContour->UpdateOutputInformation();
 
   unsigned int timestep = renderer->GetTimeStep();
 
   if ( !renderingContour->IsEmptyTimeStep(timestep) )
   {
 
     mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
     assert(displayGeometry.IsNotNull());
 
     //apply color and opacity read from the PropertyList
     ApplyColorAndOpacityProperties(renderer);
 
     mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(dataNode->GetProperty("contour.color", renderer));
     float opacity = 0.5;
     dataNode->GetFloatProperty("opacity", opacity, renderer);
 
     if(colorprop)
     {
       //set the color of the contour
       double red = colorprop->GetColor().GetRed();
       double green = colorprop->GetColor().GetGreen();
       double blue = colorprop->GetColor().GetBlue();
       glColor4f(red, green, blue, opacity);
     }
 
     mitk::ColorProperty::Pointer selectedcolor = dynamic_cast<mitk::ColorProperty*>(dataNode->GetProperty("contour.points.color", renderer));
     if(!selectedcolor)
     {
       selectedcolor = mitk::ColorProperty::New(1.0,0.0,0.1);
     }
 
 
     vtkLinearTransform* transform = dataNode->GetVtkTransform();
 
     //    ContourModel::OutputType point;
     mitk::Point3D point;
 
     mitk::Point3D p, projected_p;
     float vtkp[3];
     float lineWidth = 3.0;
 
     bool drawit=false;
 
     bool isHovering = false;
     dataNode->GetBoolProperty("contour.hovering", isHovering);
 
     if (isHovering)
         dataNode->GetFloatProperty("contour.hovering.width", lineWidth);
     else
         dataNode->GetFloatProperty("contour.width", lineWidth);
 
 
     bool showSegments = false;
     dataNode->GetBoolProperty("contour.segments.show", showSegments);
 
     bool showControlPoints = false;
     dataNode->GetBoolProperty("contour.controlpoints.show", showControlPoints);
 
     bool showPoints = false;
     dataNode->GetBoolProperty("contour.points.show", showPoints);
 
     bool showPointsNumbers = false;
     dataNode->GetBoolProperty("contour.points.text", showPointsNumbers);
 
     bool showControlPointsNumbers = false;
     dataNode->GetBoolProperty("contour.controlpoints.text", showControlPointsNumbers);
 
     bool projectmode=false;
     dataNode->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
 
 
     mitk::ContourModel::VertexIterator pointsIt = renderingContour->IteratorBegin(timestep);
 
     Point2D pt2d;       // projected_p in display coordinates
     Point2D lastPt2d;
 
     int index = 0;
 
     mitk::ScalarType maxDiff = 0.25;
 
     while ( pointsIt != renderingContour->IteratorEnd(timestep) )
     {
       lastPt2d = pt2d;
 
       point = (*pointsIt)->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
 
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetNorm();
 
       //project to plane
       if(projectmode)
       {
         drawit=true;
       }
       else if(scalardiff<maxDiff)//point is close enough to be drawn
       {
         drawit=true;
       }
       else
       {
         drawit = false;
       }
 
       //draw line
       if(drawit)
       {
 
          if (showSegments)
          {
             //lastPt2d is not valid in first step
             if( !(pointsIt == renderingContour->IteratorBegin(timestep)) )
             {
               glLineWidth(lineWidth);
               glBegin (GL_LINES);
               glVertex2f(pt2d[0], pt2d[1]);
               glVertex2f(lastPt2d[0], lastPt2d[1]);
               glEnd();
               glLineWidth(1);
             }
          }
 
 
         if (showControlPoints)
         {
             //draw ontrol points
             if ((*pointsIt)->IsControlPoint)
             {
               float pointsize = 4;
               Point2D  tmp;
 
               Vector2D horz,vert;
               horz[1]=0;
               vert[0]=0;
               horz[0]=pointsize;
               vert[1]=pointsize;
               glColor3f(selectedcolor->GetColor().GetRed(), selectedcolor->GetColor().GetBlue(), selectedcolor->GetColor().GetGreen());
               glLineWidth(1);
               //a rectangle around the point with the selected color
               glBegin (GL_LINE_LOOP);
               tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
               tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
               tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
               tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
               glEnd();
               glLineWidth(1);
               //the actual point in the specified color to see the usual color of the point
-              glColor3f(color[0],color[1],color[2]);
+              glColor3f(colorprop->GetColor().GetRed(),colorprop->GetColor().GetGreen(),colorprop->GetColor().GetBlue());
               glPointSize(1);
               glBegin (GL_POINTS);
               tmp=pt2d;             glVertex2dv(&tmp[0]);
               glEnd ();
             }
         }
 
 
         if (showPoints)
         {
           float pointsize = 3;
           Point2D  tmp;
 
           Vector2D horz,vert;
           horz[1]=0;
           vert[0]=0;
           horz[0]=pointsize;
           vert[1]=pointsize;
           glColor3f(0.0, 0.0, 0.0);
           glLineWidth(1);
           //a rectangle around the point with the selected color
           glBegin (GL_LINE_LOOP);
           tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
           tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
           tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
           tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
           glEnd();
           glLineWidth(1);
           //the actual point in the specified color to see the usual color of the point
-          glColor3f(color[0],color[1],color[2]);
+          glColor3f(colorprop->GetColor().GetRed(),colorprop->GetColor().GetGreen(),colorprop->GetColor().GetBlue());
           glPointSize(1);
           glBegin (GL_POINTS);
           tmp=pt2d;             glVertex2dv(&tmp[0]);
           glEnd ();
         }
 
 
         if (showPointsNumbers)
         {
             std::string l;
             std::stringstream ss;
             ss << index;
             l.append(ss.str());
 
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             float rgb[3];
             rgb[0] = 0.0; rgb[1] = 0.0; rgb[2] = 0.0;
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + 2, pt2d[1] + 2,rgb[0], rgb[1],rgb[2]);
         }
 
 
         if (showControlPointsNumbers && (*pointsIt)->IsControlPoint)
         {
             std::string l;
             std::stringstream ss;
             ss << index;
             l.append(ss.str());
 
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             float rgb[3];
             rgb[0] = 1.0; rgb[1] = 1.0; rgb[2] = 0.0;
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + 2, pt2d[1] + 2,rgb[0], rgb[1],rgb[2]);
         }
 
         index++;
       }
 
       pointsIt++;
     }//end while iterate over controlpoints
 
     //close contour if necessary
     if(renderingContour->IsClosed(timestep) && drawit && showSegments)
     {
       lastPt2d = pt2d;
       point = renderingContour->GetVertexAt(0,timestep)->Coordinates;
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
       displayGeometry->Project(p, projected_p);
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       glLineWidth(lineWidth);
       glBegin (GL_LINES);
       glVertex2f(lastPt2d[0], lastPt2d[1]);
       glVertex2f( pt2d[0], pt2d[1] );
       glEnd();
       glLineWidth(1);
     }
 
     //draw selected vertex if exists
     if(renderingContour->GetSelectedVertex())
     {
       //transform selected vertex
       point = renderingContour->GetSelectedVertex()->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
 
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetNorm();
       //----------------------------------
 
       //draw point if close to plane
       if(scalardiff<maxDiff)
       {
 
         float pointsize = 5;
         Point2D  tmp;
         glColor3f(0.0, 1.0, 0.0);
         glLineWidth(1);
         //a diamond around the point
         glBegin (GL_LINE_LOOP);
         //begin from upper left corner and paint clockwise
         tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2dv(&tmp[0]);
         tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2dv(&tmp[0]);
         tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2dv(&tmp[0]);
         tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2dv(&tmp[0]);
         glEnd ();
       }
       //------------------------------------
     }
   }
 }
diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
index 341dd60195..a29948904c 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
@@ -1,391 +1,391 @@
 /*===================================================================
 
 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 "mitkContourModelSetGLMapper2D.h"
 
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkContourModelSet.h"
 #include <vtkLinearTransform.h>
 #include <mitkCoreServices.h>
 #include <mitkPropertyAliases.h>
 
 #include "mitkGL.h"
 
 mitk::ContourModelSetGLMapper2D::ContourModelSetGLMapper2D()
 {
 }
 
 mitk::ContourModelSetGLMapper2D::~ContourModelSetGLMapper2D()
 {
 }
 
 
 void mitk::ContourModelSetGLMapper2D::Paint(mitk::BaseRenderer * renderer)
 {
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   mitk::DataNode* dataNode = this->GetDataNode();
   bool visible = true;
   dataNode->GetVisibility(visible, renderer, "visible");
 
   if ( !visible ) return;
 
   mitk::ContourModelSet* input =  this->GetInput();
 
   mitk::ContourModelSet::ContourModelSetIterator it = input->Begin();
 
   mitk::ContourModelSet::ContourModelSetIterator end = input->End();
 
   while(it!=end)
   {
     this->DrawContour(it->GetPointer(), renderer);
     ++it;
   }
 
   if(input->GetSize() < 1) return;
 
   ls->UpdateGenerateDataTime();
 }
 
 
 mitk::ContourModelSet* mitk::ContourModelSetGLMapper2D::GetInput(void)
 {
   return const_cast<mitk::ContourModelSet*>(static_cast<const mitk::ContourModelSet * > ( GetDataNode()->GetData() ));
 }
 
 
 void mitk::ContourModelSetGLMapper2D::DrawContour(mitk::ContourModel* renderingContour, mitk::BaseRenderer* renderer)
 {
   if(!renderingContour) return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   renderingContour->UpdateOutputInformation();
 
   unsigned int timestep = renderer->GetTimeStep();
 
   if ( !renderingContour->IsEmptyTimeStep(timestep) )
   {
 
     mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
     assert(displayGeometry.IsNotNull());
 
     //apply color and opacity read from the PropertyList
     ApplyColorAndOpacityProperties(renderer);
 
     mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(dataNode->GetProperty("contour.color", renderer));
     float opacity = 0.5;
     dataNode->GetFloatProperty("opacity", opacity, renderer);
 
     if(colorprop)
     {
       //set the color of the contour
       double red = colorprop->GetColor().GetRed();
       double green = colorprop->GetColor().GetGreen();
       double blue = colorprop->GetColor().GetBlue();
       glColor4f(red, green, blue, opacity);
     }
 
     mitk::ColorProperty::Pointer selectedcolor = dynamic_cast<mitk::ColorProperty*>(dataNode->GetProperty("contour.points.color", renderer));
     if(!selectedcolor)
     {
       selectedcolor = mitk::ColorProperty::New(1.0,0.0,0.1);
     }
 
 
     vtkLinearTransform* transform = dataNode->GetVtkTransform();
 
     //    ContourModel::OutputType point;
     mitk::Point3D point;
 
     mitk::Point3D p, projected_p;
     float vtkp[3];
     float lineWidth = 3.0;
 
     bool drawit=false;
 
     bool isHovering = false;
     dataNode->GetBoolProperty("contour.hovering", isHovering);
 
     if (isHovering)
         dataNode->GetFloatProperty("contour.hovering.width", lineWidth);
     else
         dataNode->GetFloatProperty("contour.width", lineWidth);
 
 
     bool showSegments = false;
     dataNode->GetBoolProperty("contour.segments.show", showSegments);
 
     bool showControlPoints = false;
     dataNode->GetBoolProperty("contour.controlpoints.show", showControlPoints);
 
     bool showPoints = false;
     dataNode->GetBoolProperty("contour.points.show", showPoints);
 
     bool showPointsNumbers = false;
     dataNode->GetBoolProperty("contour.points.text", showPointsNumbers);
 
     bool showControlPointsNumbers = false;
     dataNode->GetBoolProperty("contour.controlpoints.text", showControlPointsNumbers);
 
     bool projectmode=false;
     dataNode->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
 
 
     mitk::ContourModel::VertexIterator pointsIt = renderingContour->IteratorBegin(timestep);
 
     Point2D pt2d;       // projected_p in display coordinates
     Point2D lastPt2d;
 
     int index = 0;
 
     mitk::ScalarType maxDiff = 0.25;
 
     while ( pointsIt != renderingContour->IteratorEnd(timestep) )
     {
       lastPt2d = pt2d;
 
       point = (*pointsIt)->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
 
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetNorm();
 
       //project to plane
       if(projectmode)
       {
         drawit=true;
       }
       else if(scalardiff<maxDiff)//point is close enough to be drawn
       {
         drawit=true;
       }
       else
       {
         drawit = false;
       }
 
       //draw line
       if(drawit)
       {
 
          if (showSegments)
          {
             //lastPt2d is not valid in first step
             if( !(pointsIt == renderingContour->IteratorBegin(timestep)) )
             {
               glLineWidth(lineWidth);
               glBegin (GL_LINES);
               glVertex2f(pt2d[0], pt2d[1]);
               glVertex2f(lastPt2d[0], lastPt2d[1]);
               glEnd();
               glLineWidth(1);
             }
          }
 
 
         if (showControlPoints)
         {
             //draw ontrol points
             if ((*pointsIt)->IsControlPoint)
             {
               float pointsize = 4;
               Point2D  tmp;
 
               Vector2D horz,vert;
               horz[1]=0;
               vert[0]=0;
               horz[0]=pointsize;
               vert[1]=pointsize;
               glColor3f(selectedcolor->GetColor().GetRed(), selectedcolor->GetColor().GetBlue(), selectedcolor->GetColor().GetGreen());
               glLineWidth(1);
               //a rectangle around the point with the selected color
               glBegin (GL_LINE_LOOP);
               tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
               tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
               tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
               tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
               glEnd();
               glLineWidth(1);
               //the actual point in the specified color to see the usual color of the point
-              glColor3f(color[0],color[1],color[2]);
+              glColor3f(colorprop->GetColor().GetRed(),colorprop->GetColor().GetGreen(),colorprop->GetColor().GetBlue());
               glPointSize(1);
               glBegin (GL_POINTS);
               tmp=pt2d;             glVertex2dv(&tmp[0]);
               glEnd ();
             }
         }
 
 
         if (showPoints)
         {
           float pointsize = 3;
           Point2D  tmp;
 
           Vector2D horz,vert;
           horz[1]=0;
           vert[0]=0;
           horz[0]=pointsize;
           vert[1]=pointsize;
           glColor3f(0.0, 0.0, 0.0);
           glLineWidth(1);
           //a rectangle around the point with the selected color
           glBegin (GL_LINE_LOOP);
           tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
           tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
           tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
           tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
           glEnd();
           glLineWidth(1);
           //the actual point in the specified color to see the usual color of the point
-          glColor3f(color[0],color[1],color[2]);
+          glColor3f(colorprop->GetColor().GetRed(),colorprop->GetColor().GetGreen(),colorprop->GetColor().GetBlue());
           glPointSize(1);
           glBegin (GL_POINTS);
           tmp=pt2d;             glVertex2dv(&tmp[0]);
           glEnd ();
         }
 
 
         if (showPointsNumbers)
         {
             std::string l;
             std::stringstream ss;
             ss << index;
             l.append(ss.str());
 
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             float rgb[3];
             rgb[0] = 0.0; rgb[1] = 0.0; rgb[2] = 0.0;
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + 2, pt2d[1] + 2,rgb[0], rgb[1],rgb[2]);
         }
 
 
         if (showControlPointsNumbers && (*pointsIt)->IsControlPoint)
         {
             std::string l;
             std::stringstream ss;
             ss << index;
             l.append(ss.str());
 
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             float rgb[3];
             rgb[0] = 1.0; rgb[1] = 1.0; rgb[2] = 0.0;
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + 2, pt2d[1] + 2,rgb[0], rgb[1],rgb[2]);
         }
 
         index++;
       }
 
       pointsIt++;
     }//end while iterate over controlpoints
 
     //close contour if necessary
     if(renderingContour->IsClosed(timestep) && drawit && showSegments)
     {
       lastPt2d = pt2d;
       point = renderingContour->GetVertexAt(0,timestep)->Coordinates;
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
       displayGeometry->Project(p, projected_p);
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       glLineWidth(lineWidth);
       glBegin (GL_LINES);
       glVertex2f(lastPt2d[0], lastPt2d[1]);
       glVertex2f( pt2d[0], pt2d[1] );
       glEnd();
       glLineWidth(1);
     }
 
     //draw selected vertex if exists
     if(renderingContour->GetSelectedVertex())
     {
       //transform selected vertex
       point = renderingContour->GetSelectedVertex()->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
 
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetNorm();
       //----------------------------------
 
       //draw point if close to plane
       if(scalardiff<maxDiff)
       {
 
         float pointsize = 5;
         Point2D  tmp;
         glColor3f(0.0, 1.0, 0.0);
         glLineWidth(1);
         //a diamond around the point
         glBegin (GL_LINE_LOOP);
         //begin from upper left corner and paint clockwise
         tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2dv(&tmp[0]);
         tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2dv(&tmp[0]);
         tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2dv(&tmp[0]);
         tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2dv(&tmp[0]);
         glEnd ();
       }
       //------------------------------------
     }
   }
 }
 
 void mitk::ContourModelSetGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite );
   node->AddProperty( "contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), renderer, overwrite );
   node->AddProperty( "contour.points.show", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "contour.segments.show", mitk::BoolProperty::New( true ), renderer, overwrite );
   node->AddProperty( "contour.controlpoints.show", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "contour.width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
   node->AddProperty( "contour.hovering.width", mitk::FloatProperty::New( 3.0 ), renderer, overwrite );
   node->AddProperty( "contour.hovering", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "contour.points.text", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "contour.controlpoints.text", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   node->AddProperty( "contour.project-onto-plane", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
 
   IPropertyAliases* aliases = CoreServices::GetPropertyAliases();
 
   if(aliases != NULL)
   {
     aliases->AddAlias("color", "contour.color", "ContourModelSet");
   }
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Modules/DicomRT/CMakeLists.txt b/Modules/DicomRT/CMakeLists.txt
index 4e2d45448d..56e50c2ab7 100644
--- a/Modules/DicomRT/CMakeLists.txt
+++ b/Modules/DicomRT/CMakeLists.txt
@@ -1,12 +1,12 @@
 # CREATE MODULE HERE
 IF (NOT DEFINED DCMTK_dcmrt_LIBRARY OR DCMTK_dcmrt_LIBRARY)
-MITK_CREATE_MODULE(mitkDicomRT
+MITK_CREATE_MODULE(
   INCLUDE_DIRS DataStructures
-  DEPENDS Mitk Segmentation SceneSerializationBase
+  DEPENDS MitkSegmentation MitkSceneSerializationBase
   PACKAGE_DEPENDS DCMTK
   QT_MODULE
 )
 ADD_SUBDIRECTORY(Testing)
 ELSE()
 MESSAGE("MITK DicomRT Support disabled because the DCMTK dcmrt library not found")
 ENDIF()
diff --git a/Modules/DicomRT/DataStructures/mitkIsoDoseLevel.h b/Modules/DicomRT/DataStructures/mitkIsoDoseLevel.h
index 3045101d8d..9c89d53f84 100644
--- a/Modules/DicomRT/DataStructures/mitkIsoDoseLevel.h
+++ b/Modules/DicomRT/DataStructures/mitkIsoDoseLevel.h
@@ -1,104 +1,104 @@
 /*===================================================================
 
 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_DOSE_ISO_LEVEL_H_
 #define _MITK_DOSE_ISO_LEVEL_H_
 
 #include <itkRGBPixel.h>
 #include <itkObject.h>
 #include <itkObjectFactory.h>
 
 #include "mitkCommon.h"
 #include "mitkDoseValueType.h"
-#include "mitkDicomRTExports.h"
+#include "MitkDicomRTExports.h"
 
 namespace mitk
 {
 
   /**
   \brief Stores values needed for the representation/visualization of dose iso levels.
   *
   * The dose iso level is defined in the topology of a dose distribution by the dose value
   * that indicates the lower boundary of the iso level. The upper boundary is implicitly defined
   * by the next IsoDoseLevel greater (higher dose value) than the current iso level.
   * Color and the visibility options are used to indicate the visualization style.
   */
-  class mitkDicomRT_EXPORT IsoDoseLevel: public itk::Object
+  class MitkDicomRT_EXPORT IsoDoseLevel: public itk::Object
   {
   public:
     typedef ::itk::RGBPixel<float> ColorType;
     typedef DoseValueRel DoseValueType;
 
     mitkClassMacro(IsoDoseLevel, itk::Object);
     itkNewMacro(Self);
     mitkNewMacro4Param(Self,DoseValueType, ColorType, bool, bool);
 
     /** Checks if current dose iso level instances is greater
      according to the dose values.*/
     bool operator> ( const IsoDoseLevel& right ) const;
     /** Checks if current dose iso level instances is lesser
      according to the dose values.*/
     bool operator< ( const IsoDoseLevel& right ) const;
 
     bool operator == ( const IsoDoseLevel& right) const;
 
     itkSetMacro(DoseValue,DoseValueType);
     itkGetConstMacro(DoseValue,DoseValueType);
 
     itkSetMacro(Color,ColorType);
     itkGetConstMacro(Color,ColorType);
 
     itkSetMacro(VisibleIsoLine,bool);
     itkGetConstMacro(VisibleIsoLine,bool);
     itkBooleanMacro(VisibleIsoLine);
 
     itkSetMacro(VisibleColorWash,bool);
     itkGetConstMacro(VisibleColorWash,bool);
     itkBooleanMacro(VisibleColorWash);
 
   protected:
     IsoDoseLevel();
     IsoDoseLevel(const IsoDoseLevel & other);
     IsoDoseLevel(const DoseValueType & value, const ColorType& color, bool visibleIsoLine = true, bool visibleColorWash = true );
     virtual ~IsoDoseLevel();
 
     mitkCloneMacro(IsoDoseLevel);
 
     void PrintSelf(std::ostream &os, itk::Indent indent) const;
 
   private:
     /** Relative dose value and lower boundary of the iso level instance
      */
     DoseValueType m_DoseValue;
 
     /** RGB color code that should be used for the iso level.*/
     ColorType m_Color;
 
     /** indicates if an iso line should be shown for the iso level
      (the lower boundary indicated by m_DoseValue)*/
     bool m_VisibleIsoLine;
 
     /** indicates if a color wash should be shown for the iso level.*/
     bool m_VisibleColorWash;
 
     /** Not implemented on purpose*/
     IsoDoseLevel& operator = (const IsoDoseLevel& source);
   };
 
 } // namespace mitk
 
 #endif //_MITK_DOSE_ISO_LEVEL_H_
diff --git a/Modules/DicomRT/DataStructures/mitkIsoDoseLevelCollections.h b/Modules/DicomRT/DataStructures/mitkIsoDoseLevelCollections.h
index 3099aa2e6f..9f674d59ed 100644
--- a/Modules/DicomRT/DataStructures/mitkIsoDoseLevelCollections.h
+++ b/Modules/DicomRT/DataStructures/mitkIsoDoseLevelCollections.h
@@ -1,161 +1,161 @@
 /*===================================================================
 
 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_DOSE_ISO_LEVEL_COLLECTIONS_H_
 #define _MITK_DOSE_ISO_LEVEL_COLLECTIONS_H_
 
 #include <set>
 #include <itkVectorContainer.h>
 
 #include "mitkIsoDoseLevel.h"
 
 namespace mitk
 {
 
 
   /**
   \class IsoDoseLevelVector
   \brief Simple vector that stores dose iso levels.
   *
   * This class is for example used to store the user defined free iso values.
   */
   typedef ::itk::VectorContainer<unsigned int, mitk::IsoDoseLevel::Pointer> IsoDoseLevelVector;
 
 
   /**
   \class IsoDoseLevelSet
   \brief Stores values needed for the representation/visualization of dose iso levels.
   *
   * Set of dose iso levels sorted by the dose values of the iso levels (low to high values).
   * This data structure is used to represent the dose iso level setup used for the
   * visualization of a dose distribution.
   */
-class mitkDicomRT_EXPORT IsoDoseLevelSet:
+class MitkDicomRT_EXPORT IsoDoseLevelSet:
   public itk::Object
 {
 public:
   mitkClassMacro(IsoDoseLevelSet, itk::Object);
   itkNewMacro(Self);
 
 private:
   /** Quick access to the STL vector type that was inherited. */
   typedef std::vector< IsoDoseLevel::Pointer > InternalVectorType;
   typedef InternalVectorType::size_type      size_type;
   typedef InternalVectorType::iterator       VectorIterator;
   typedef InternalVectorType::const_iterator VectorConstIterator;
 
   InternalVectorType m_IsoLevels;
 
 protected:
   IsoDoseLevelSet() {};
   IsoDoseLevelSet(const IsoDoseLevelSet & other);
 
   virtual ~IsoDoseLevelSet() {};
 
   mitkCloneMacro(IsoDoseLevelSet);
 
 public:
   typedef size_type IsoLevelIndexType;
   typedef IsoDoseLevel::DoseValueType DoseValueType;
 
   /** Convenient typedefs for the iterator and const iterator. */
   class ConstIterator;
 
   /** Friends to this class. */
   friend class ConstIterator;
 
   /** \class ConstIterator
    * Simulate STL-vector style const iteration where dereferencing the iterator
    * gives read access to the value.
    */
   class ConstIterator
   {
 public:
     ConstIterator() {}
     ConstIterator(const VectorConstIterator & i): m_Iter(i) {}
     ConstIterator(const ConstIterator & r) { m_Iter = r.m_Iter; }
     const IsoDoseLevel & operator*()    { return *(m_Iter->GetPointer()); }
     const IsoDoseLevel * operator->()   { return m_Iter->GetPointer(); }
     ConstIterator & operator++()   {++m_Iter; return *this; }
     ConstIterator operator++(int) { ConstIterator temp(*this); ++m_Iter; return temp; }
     ConstIterator & operator--()   {--m_Iter; return *this; }
     ConstIterator operator--(int) { ConstIterator temp(*this); --m_Iter; return temp; }
     ConstIterator & operator=(const ConstIterator & r) {m_Iter = r.m_Iter; return *this; }
     bool operator==(const ConstIterator & r) const { return m_Iter == r.m_Iter; }
     bool operator!=(const ConstIterator & r) const { return m_Iter != r.m_Iter; }
 
     const IsoDoseLevel & Value(void) const { return *(m_Iter->GetPointer()); }
 
 private:
     VectorConstIterator m_Iter;
   };
 
   /* Declare the public interface routines. */
 
   /**
    * Read the element from the given index.
    * It is assumed that the index exists.
    */
   const IsoDoseLevel& GetIsoDoseLevel(IsoLevelIndexType) const;
   const IsoDoseLevel& GetIsoDoseLevel(DoseValueType) const;
 
   /**
    * Set the element value at the given index.
    * It is assumed that the index exists.
    */
   void SetIsoDoseLevel(const IsoDoseLevel*);
 
   /**
    * Check if the index range of the vector is large enough to allow the
    * given index without expansion.
    */
   bool DoseLevelExists(IsoLevelIndexType) const;
   bool DoseLevelExists(DoseValueType) const;
 
   /**
    * Delete the element defined by the index identifier.  In practice, it
    * doesn't make sense to delete a vector index.  Instead, this method just
    * overwrites the index with the default element.
    */
   void DeleteIsoDoseLevel(DoseValueType);
   void DeleteIsoDoseLevel(IsoLevelIndexType);
 
   /**
    * Get a begin const iterator for the vector.
    */
   ConstIterator Begin(void) const;
 
   /**
    * Get an end const iterator for the vector.
    */
   ConstIterator End(void) const;
 
   /**
    * Get the number of elements currently stored in the vector.
    */
   IsoLevelIndexType Size(void) const;
 
   /**
    * Clear the elements. The final size will be zero.
    */
   void Reset(void);
 };
 
 
 }
 
 #endif //_MITK_DOSE_ISO_LEVEL_COLLECTIONS_H_
diff --git a/Modules/DicomRT/DataStructures/mitkIsoDoseLevelSetProperty.h b/Modules/DicomRT/DataStructures/mitkIsoDoseLevelSetProperty.h
index 18065fe1e3..9f95ee3fb6 100644
--- a/Modules/DicomRT/DataStructures/mitkIsoDoseLevelSetProperty.h
+++ b/Modules/DicomRT/DataStructures/mitkIsoDoseLevelSetProperty.h
@@ -1,82 +1,82 @@
 /*===================================================================
 
 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_DOSE_ISO_LEVEL_SET_PROPERTY_H_
 #define _MITK_DOSE_ISO_LEVEL_SET_PROPERTY_H_
 
 #include "mitkBaseProperty.h"
 #include "mitkIsoDoseLevelCollections.h"
-#include "mitkDicomRTExports.h"
+#include "MitkDicomRTExports.h"
 
 namespace mitk {
 
 
 /**
 \brief Property class for dose iso level sets.
 */
-class mitkDicomRT_EXPORT IsoDoseLevelSetProperty : public BaseProperty
+class MitkDicomRT_EXPORT IsoDoseLevelSetProperty : public BaseProperty
 {
 
 protected:
     IsoDoseLevelSet::Pointer m_IsoLevelSet;
 
     IsoDoseLevelSetProperty();
 
     IsoDoseLevelSetProperty(const IsoDoseLevelSetProperty& other);
 
     IsoDoseLevelSetProperty(IsoDoseLevelSet* levelSet);
 
 public:
     mitkClassMacro(IsoDoseLevelSetProperty, BaseProperty);
 
     itkNewMacro(IsoDoseLevelSetProperty);
     mitkNewMacro1Param(IsoDoseLevelSetProperty, IsoDoseLevelSet*);
 
     typedef IsoDoseLevelSet ValueType;
 
     virtual ~IsoDoseLevelSetProperty();
 
     const IsoDoseLevelSet * GetIsoDoseLevelSet() const;
     const IsoDoseLevelSet * GetValue() const;
     IsoDoseLevelSet * GetIsoDoseLevelSet();
     IsoDoseLevelSet * GetValue();
 
 
     void SetIsoDoseLevelSet(IsoDoseLevelSet* levelSet);
     void SetValue(IsoDoseLevelSet* levelSet);
 
     virtual std::string GetValueAsString() const;
 
     using BaseProperty::operator=;
 
 private:
 
     // purposely not implemented
     IsoDoseLevelSetProperty& operator=(const IsoDoseLevelSetProperty&);
 
     itk::LightObject::Pointer InternalClone() const;
 
     virtual bool IsEqual(const BaseProperty& property) const;
     virtual bool Assign(const BaseProperty& property);
 
 };
 
 } // namespace mitk
 
 
 
 #endif /* _MITK_DOSE_ISO_LEVEL_SET_PROPERTY_H_ */
diff --git a/Modules/DicomRT/DataStructures/mitkIsoDoseLevelVectorProperty.h b/Modules/DicomRT/DataStructures/mitkIsoDoseLevelVectorProperty.h
index c83651aafd..cd2921e877 100644
--- a/Modules/DicomRT/DataStructures/mitkIsoDoseLevelVectorProperty.h
+++ b/Modules/DicomRT/DataStructures/mitkIsoDoseLevelVectorProperty.h
@@ -1,82 +1,82 @@
 /*===================================================================
 
 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_DOSE_ISO_LEVEL_VECTOR_PROPERTY_H_
 #define _MITK_DOSE_ISO_LEVEL_VECTOR_PROPERTY_H_
 
 #include "mitkBaseProperty.h"
 #include "mitkIsoDoseLevelCollections.h"
-#include "mitkDicomRTExports.h"
+#include "MitkDicomRTExports.h"
 
 namespace mitk {
 
 
 /**
 \brief Property class for dose iso level vector.
 */
-class mitkDicomRT_EXPORT IsoDoseLevelVectorProperty : public BaseProperty
+class MitkDicomRT_EXPORT IsoDoseLevelVectorProperty : public BaseProperty
 {
 
 protected:
     IsoDoseLevelVector::Pointer m_IsoLevelVector;
 
     IsoDoseLevelVectorProperty();
 
     IsoDoseLevelVectorProperty(const IsoDoseLevelVectorProperty& other);
 
     IsoDoseLevelVectorProperty(IsoDoseLevelVector* levelVector);
 
 public:
     mitkClassMacro(IsoDoseLevelVectorProperty, BaseProperty);
 
     itkNewMacro(IsoDoseLevelVectorProperty);
     mitkNewMacro1Param(IsoDoseLevelVectorProperty, IsoDoseLevelVector*);
 
     typedef IsoDoseLevelVector ValueType;
 
     virtual ~IsoDoseLevelVectorProperty();
 
     const IsoDoseLevelVector * GetIsoDoseLevelVector() const;
     const IsoDoseLevelVector * GetValue() const;
     IsoDoseLevelVector * GetIsoDoseLevelVector();
     IsoDoseLevelVector * GetValue();
 
 
     void SetIsoDoseLevelVector(IsoDoseLevelVector* levelVector);
     void SetValue(IsoDoseLevelVector* levelVector);
 
     virtual std::string GetValueAsString() const;
 
     using BaseProperty::operator=;
 
 private:
 
     // purposely not implemented
     IsoDoseLevelVectorProperty& operator=(const IsoDoseLevelVectorProperty&);
 
     itk::LightObject::Pointer InternalClone() const;
 
     virtual bool IsEqual(const BaseProperty& property) const;
     virtual bool Assign(const BaseProperty& property);
 
 };
 
 } // namespace mitk
 
 
 
 #endif /* _MITK_DOSE_ISO_LEVEL_SET_PROPERTY_H_ */
diff --git a/Modules/DicomRT/DataStructures/mitkRTConstants.h b/Modules/DicomRT/DataStructures/mitkRTConstants.h
index 7a591b9151..69d8783905 100644
--- a/Modules/DicomRT/DataStructures/mitkRTConstants.h
+++ b/Modules/DicomRT/DataStructures/mitkRTConstants.h
@@ -1,90 +1,90 @@
 /*===================================================================
 
 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_RT_CONSTANTS_H_
 #define _MITK_RT_CONSTANTS_H_
 
 #include <string>
 
-#include "mitkDicomRTExports.h"
+#include "MitkDicomRTExports.h"
 
 namespace mitk
 {
   namespace rt
   {
-    struct mitkDicomRT_EXPORT Constants
+    struct MitkDicomRT_EXPORT Constants
     {
       /**
       * Name of the property that indicates if a data/node is a dose.
       */
       static const std::string DOSE_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes the prescribed dose associated with the data node
       * If a RTPLAN file exists the value can be extracted from the tag (300A,0026) - Target Prescription Dose in the plan file.
       */
       static const std::string PRESCRIBED_DOSE_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes the reference dose that should be used for relative dose vizualization/evaluation purpose.
       * It is often the prescribed dose but may differ e.g. when to dose distributions sould be compared using the same reference.
       */
       static const std::string REFERENCE_DOSE_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes the optional string property holding the information from the tag (3004,0004) - Dose Type.
       * This contains useful information for medical doctors
       */
       static const std::string DOSE_TYPE_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes the optional string property holding the information from the tag (3004,000A) - Dose Summation Type.
       * This contains useful information for medical doctors
       */
       static const std::string DOSE_SUMMATION_TYPE_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes the number of fractions.
       * It is for example in DICOM stored in tag (300A,0078) - Number of Fractions Prescribed (from the RTPLAN file if this file exists).
       * This value could be used to further scale the dose according to dose summation type.
       * For example a given plan consists of 8 fractions. Scaling the fraction dose by 8 gives the complete planned dose.
       */
       static const std::string DOSE_FRACTION_COUNT_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes if the iso line rendering should be activated for the node.
       */
       static const std::string DOSE_SHOW_ISOLINES_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes if the color wash rendering should be activated for the node.
       */
       static const std::string DOSE_SHOW_COLORWASH_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes if the set of iso levels should be used to visualize the dose distribution.
       */
       static const std::string DOSE_ISO_LEVELS_PROPERTY_NAME;
 
       /**
       * Name of the property that encodes user defined iso values that mark special dose values in the distribution.
       */
       static const std::string DOSE_FREE_ISO_VALUES_PROPERTY_NAME;
     };
   }
 }
 
 #endif
diff --git a/Modules/DicomRT/Testing/files.cmake b/Modules/DicomRT/Testing/files.cmake
index d1458a00e5..744a5ab21b 100644
--- a/Modules/DicomRT/Testing/files.cmake
+++ b/Modules/DicomRT/Testing/files.cmake
@@ -1,4 +1,3 @@
 SET(MODULE_TESTS
-  mitkDicomRTWriterTest.cpp
   mitkDicomRTReaderTest.cpp
 )
diff --git a/Modules/DicomRT/Testing/mitkDicomRTWriterTest.cpp b/Modules/DicomRT/Testing/mitkDicomRTWriterTest.cpp
deleted file mode 100644
index 0ccf1b6311..0000000000
--- a/Modules/DicomRT/Testing/mitkDicomRTWriterTest.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*===================================================================
-
-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 "mitkTestingMacros.h"
-#include "mitkDicomRTWriter.h"
-#include <iostream>
-
-/**
- *  blaaa
- */
-int mitkDicomRTWriterTest(int /* argc */, char* /*argv*/[])
-{
-  // always start with this!
-  MITK_TEST_BEGIN("DicomRTWriter")
-
-  mitk::DicomRTWriter::Pointer _DicomRTWriter = mitk::DicomRTWriter::New();
-
-  std::string helloWorld = _DicomRTWriter->SayHelloWorld();
-
-  MITK_TEST_CONDITION_REQUIRED( helloWorld == "Hello World", "SayHelloWorld worked correctly" );
-
-  // always end with this!
-  MITK_TEST_END()
-}
-
diff --git a/Modules/DicomRT/files.cmake b/Modules/DicomRT/files.cmake
index d596025962..b209527aca 100644
--- a/Modules/DicomRT/files.cmake
+++ b/Modules/DicomRT/files.cmake
@@ -1,26 +1,24 @@
 SET(CPP_FILES
-  mitkDicomRTWriter.cpp
   mitkDicomRTReader.cpp
   DataStructures/mitkRTConstants.cpp
   DataStructures/mitkIsoDoseLevel.cpp
   DataStructures/mitkIsoDoseLevelCollections.cpp
   DataStructures/mitkIsoDoseLevelSetProperty.cpp
   DataStructures/mitkIsoDoseLevelVectorProperty.cpp
 )
 
 set(H_FILES
-  mitkDicomRTWriter.h
   mitkDicomRTReader.h
   DataStructures/mitkIsoDoseLevel.h
   DataStructures/mitkIsoDoseLevelCollections.h
   DataStructures/mitkIsoDoseLevelSetProperty.h
   DataStructures/mitkIsoDoseLevelVectorProperty.h
   DataStructures/mitkDoseValueType.h
   DataStructures/mitkRTConstants.h
 )
 
 set(TPP_FILES
 )
 
 set(MOC_H_FILES
 )
diff --git a/Modules/DicomRT/mitkDicomRTReader.h b/Modules/DicomRT/mitkDicomRTReader.h
index 790843e327..5212787338 100644
--- a/Modules/DicomRT/mitkDicomRTReader.h
+++ b/Modules/DicomRT/mitkDicomRTReader.h
@@ -1,232 +1,232 @@
 /*===================================================================
 
 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 mitkDicomRTReader_h
 #define mitkDicomRTReader_h
 
 #include <itkObject.h>
 #include <itkObjectFactory.h>
 #include <mitkCommon.h>
-#include <mitkDicomRTExports.h>
+#include <MitkDicomRTExports.h>
 #include "mitkContourModel.h"
 #include "mitkContourElement.h"
 #include <mitkContourModelSet.h>
 
 #include "dcmtk/config/osconfig.h"
 #include "dcmtk/ofstd/ofconapp.h"
 
 #include "dcmtk/ofstd/ofcond.h"
 
 #include "dcmtk/dcmrt/drtdose.h"
 #include "dcmtk/dcmrt/drtimage.h"
 #include "dcmtk/dcmrt/drtplan.h"
 #include "dcmtk/dcmrt/drttreat.h"
 #include "dcmtk/dcmrt/drtionpl.h"
 #include "dcmtk/dcmrt/drtiontr.h"
 
 #include <fstream>
 #include <mitkImage.h>
 #include <mitkPixelType.h>
 #include <mitkDataNode.h>
 #include <mitkProperties.h>
 #include <mitkRenderingModeProperty.h>
 #include <mitkDataNodeFactory.h>
 #include <itkGDCMSeriesFileNames.h>
 #include <mitkDicomSeriesReader.h>
 #include <DataStructures/mitkRTConstants.h>
 
 #include <mitkCoreServices.h>
 #include <mitkIShaderRepository.h>
 
 #include "dcmtk/dcmrt/drtstrct.h"
 
 #include <vtkObjectFactory.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkRibbonFilter.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkSmartPointer.h>
 #include <vtkCleanPolyData.h>
 
 class vtkPolyData;
 class DcmDataset;
 class OFString;
 class DRTContourSequence;
 class DRTStructureSetIOD;
 
 namespace mitk
 {
 
-  class mitkDicomRT_EXPORT DicomRTReader: public itk::Object
+  class MitkDicomRT_EXPORT DicomRTReader: public itk::Object
   {
 
     typedef std::deque<mitk::ContourModelSet::Pointer> ContourModelSetVector;
 
     /**
      * @brief Describes and holds some information about the beams.
      */
     class BeamEntry
     {
     public:
       BeamEntry()
       {
         Number=-1;
         SrcAxisDistance=0.0;
         GantryAngle=0.0;
         PatientSupportAngle=0.0;
         BeamLimitingDeviceAngle=0.0;
         LeafJawPositions[0][0]=0.0;
         LeafJawPositions[0][1]=0.0;
         LeafJawPositions[1][0]=0.0;
         LeafJawPositions[1][1]=0.0;
       }
       unsigned int Number;
       std::string Name;
       std::string Type;
       std::string Description;
       double SrcAxisDistance;
       double GantryAngle;
       double PatientSupportAngle;
       double BeamLimitingDeviceAngle;
       double LeafJawPositions[2][2];
     };
 
     /**
      * @brief Describes and holds some information about the Rois.
      */
     class RoiEntry
     {
     public:
       RoiEntry();
       virtual ~RoiEntry();
       RoiEntry(const RoiEntry& src);
       RoiEntry &operator=(const RoiEntry &src);
 
       void SetPolyData(ContourModelSet::Pointer roiPolyData);
 
       unsigned int Number;
       std::string  Name;
       std::string  Description;
       double       DisplayColor[3];
       mitk::ContourModelSet::Pointer ContourModelSet;
     };
 
   public:
 
     mitkClassMacro( DicomRTReader, itk::Object );
     itkNewMacro( Self );
 
     /**
      * @brief Get the maximum dose value from the dose file
      * @param dataSet The DcmDataset of the DicomRTDose file
      * @return  The dose value
      *
      * Checks all pixel values for the maximum value
      */
     double GetMaxDoseValue(DcmDataset* dataSet);
 
     /**
      * @brief Used for reading a DicomRT file
      * @param filename The path with your file which you want to read
      *
      * Calls the right method for reading a dose, structure or plan file.
      */
     ContourModelSetVector ReadDicomFile(char* filename);
 
     /**
      * @brief Reads a DcmDataset from a DicomRT structureset file
      * @param dataset DcmDataset-object from DCMTK
      * @return Returns a Deque with mitk::ContourModelSet
      *
      * The returned mitk::ContourModelSet represent exactly one Roi/Structureset.
      * So the size of the returned deque is the number of Rois. The names of the
      * rois is stored in their mitk::Property.
      */
     ContourModelSetVector ReadStructureSet(DcmDataset* dataset);
 
     /**
      * @brief Reads a DcmDataset from a DicomRT plan file
      * @param dataset DcmDataset-object from DCMTK
      * @return The return doesnt make senese at the moment
      *
      * This method isnt ready for use at the moment. Dont use it!
      */
     int LoadRTPlan(DcmDataset* dataset);
 
     /**
      * @brief Reads a DcmDataset from a DicomRT dose file
      * @param dataset  DcmDataset-object from DCMTK
      * @param filename The path with the dose file used for getting the geometry
      * @return Returns a mitk::DataNode::Pointer in which a mitk::Image is stored
      *
      * The method reads the PixelData from the DicomRT dose file and scales them
      * with a factor for getting Gray-values instead of pixel-values.
      * The Gray-values are stored in a mitk::Image with an vtkColorTransferFunction.
      * Relative values are used for coloring the image. The relative values are
      * relative to a PrescriptionDose definied in the RT-Plan. If there is no
      * RT-Plan file PrescriptionDose is set to 80% of the maximum dose.
      */
     mitk::DataNode::Pointer LoadRTDose(DcmDataset* dataset, char* filename);
 
     /**
      * @brief Returns the number of Rois stored in the RoiSequenceVector
      * @return unsigned long size_t Number of Rois
      */
     size_t GetNumberOfRois();
 
     /**
      * @brief Find a Roi stored in the RoiSequenceVector by his number
      * @param roiNumber The number of the searched roi
      * @return Returns a mitk::DicomRTReader::RoiEntry object
      */
     RoiEntry* FindRoiByNumber(unsigned int roiNumber);
 
     /**
      * @brief GetReferencedFrameOfReferenceSOPInstanceUID
      * @param structSetObject
      * @return
      */
     OFString GetReferencedFrameOfReferenceSOPInstanceUID(DRTStructureSetIOD &structSetObject);
 
     /**
     * Virtual destructor.
     */
     virtual ~DicomRTReader();
 
   protected:
 
     /**
      * @brief Storing the Rois found in the Structureset file
      */
     std::vector<RoiEntry> RoiSequenceVector;
 
     /**
      * @brief Storing the Beams foud in the RT Plan file
      */
     std::vector<BeamEntry> BeamSequenceVector;
 
     /**
     * Constructor.
     */
     DicomRTReader();
 
   };
 
 }
 
 #endif
diff --git a/Modules/DicomRT/mitkDicomRTWriter.cpp b/Modules/DicomRT/mitkDicomRTWriter.cpp
deleted file mode 100644
index 983a47a090..0000000000
--- a/Modules/DicomRT/mitkDicomRTWriter.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*===================================================================
-
-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 "mitkDicomRTWriter.h"
-
-namespace mitk
-{
-
-DicomRTWriter::DicomRTWriter()
-{
-}
-
-DicomRTWriter::~DicomRTWriter()
-{
-}
-
-std::string DicomRTWriter::SayHelloWorld()
-{
-  return "Hello World";
-}
-
-
-} // namespace
diff --git a/Modules/DicomRT/mitkDicomRTWriter.h b/Modules/DicomRT/mitkDicomRTWriter.h
deleted file mode 100644
index 1621c98555..0000000000
--- a/Modules/DicomRT/mitkDicomRTWriter.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*===================================================================
-
-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 mitkDicomRTWriter_h
-#define mitkDicomRTWriter_h
-
-#include <itkObject.h>
-#include <itkObjectFactory.h>
-#include <mitkCommon.h>
-#include <mitkDicomRTExports.h>
-
-namespace mitk
-{
-
-/**
- * @brief bla
- *
- */
-class mitkDicomRT_EXPORT DicomRTWriter: public itk::Object
-{
-public:
-
-  mitkClassMacro( DicomRTWriter, itk::Object );
-
-  itkNewMacro( Self );
-
-  std::string SayHelloWorld();
-
-  /**
-  * Virtual destructor.
-  */
-  virtual ~DicomRTWriter();
-
-protected:
-
-  /**
-  * Constructor.
-  */
-  DicomRTWriter();
-
-};
-
-
-
-}
-
-
-#endif
diff --git a/Modules/RTUI/CMakeLists.txt b/Modules/RTUI/CMakeLists.txt
index 1bc0607a67..f8a8ea7efb 100644
--- a/Modules/RTUI/CMakeLists.txt
+++ b/Modules/RTUI/CMakeLists.txt
@@ -1,6 +1,6 @@
-MITK_CREATE_MODULE(RTUI
+MITK_CREATE_MODULE(
   INCLUDE_DIRS Qmitk Helper
-  DEPENDS mitkDicomRT Qmitk QmitkExt
+  DEPENDS MitkDicomRT MitkQtWidgets MitkQtWidgetsExt
   PACKAGE_DEPENDS CTK
   QT_MODULE
 )
diff --git a/Modules/RTUI/Helper/mitkIsoLevelsGenerator.h b/Modules/RTUI/Helper/mitkIsoLevelsGenerator.h
index 9367280be4..3c42821a6b 100644
--- a/Modules/RTUI/Helper/mitkIsoLevelsGenerator.h
+++ b/Modules/RTUI/Helper/mitkIsoLevelsGenerator.h
@@ -1,33 +1,33 @@
 /*===================================================================
 
 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 __ISO_LEVELS_GENERATOR_H
 #define __ISO_LEVELS_GENERATOR_H
 
 #include "mitkIsoDoseLevelCollections.h"
 
-#include "RTUIExports.h"
+#include "MitkRTUIExports.h"
 
 namespace mitk
 {
   namespace rt
   {
-    IsoDoseLevelSet::Pointer RTUI_EXPORT GeneratIsoLevels_Virtuos();
+    IsoDoseLevelSet::Pointer MitkRTUI_EXPORT GeneratIsoLevels_Virtuos();
   }
 }
 
 #endif
diff --git a/Modules/RTUI/Helper/mitkRTUIConstants.h b/Modules/RTUI/Helper/mitkRTUIConstants.h
index 87b1535479..081177ac0d 100644
--- a/Modules/RTUI/Helper/mitkRTUIConstants.h
+++ b/Modules/RTUI/Helper/mitkRTUIConstants.h
@@ -1,86 +1,86 @@
 /*===================================================================
 
 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_RT_UI_CONSTANTS_H_
 #define _MITK_RT_UI_CONSTANTS_H_
 
 #include <string>
 #include <mitkDoseValueType.h>
 
-#include "RTUIExports.h"
+#include "MitkRTUIExports.h"
 
 namespace mitk
 {
   namespace rt
   {
-    struct RTUI_EXPORT UIConstants
+    struct MitkRTUI_EXPORT UIConstants
     {
       /** ID/Path of main preference node for RT UI.  */
       static const std::string ROOT_PREFERENCE_NODE_ID;
       /** Bool that indicates how the prescribed dose should be defined, if unkown. True: UNKNOWN_PRESCRIBED_DOSE_HANDLING_VALUE should be used as
       default dose value in Gy; False: it should be used as fraction of the max dose to determin the prescribed dose.*/
       static const std::string UNKNOWN_PRESCRIBED_DOSE_HANDLING_AS_DEFAULT_ID;
       /** Value that is used to determin unknown prescribed doses.*/
       static const std::string UNKNOWN_PRESCRIBED_DOSE_HANDLING_VALUE_ID;
 
       /** ID/Path of main preference node where all iso dose level presets are stored (e.g. ROOT_ISO_PRESETS_PREFERENCE_NODE_ID+"/[Preset1]").  */
       static const std::string ROOT_ISO_PRESETS_PREFERENCE_NODE_ID;
       /** ID/Path of main preference for dose visualization preferences.  */
       static const std::string ROOT_DOSE_VIS_PREFERENCE_NODE_ID;
       /** ID for the reference dose stored as preference.  */
       static const std::string REFERENCE_DOSE_ID;
       /** ID for the preference flag that indicates if the reference dose is synced for all nodes*/
       static const std::string GLOBAL_REFERENCE_DOSE_SYNC_ID;
       /** ID for the flag if dose should be displayed as absoulte dose.  */
       static const std::string DOSE_DISPLAY_ABSOLUTE_ID;
       /** ID for the global visiblity switch for iso line visualization.  */
       static const std::string GLOBAL_VISIBILITY_ISOLINES_ID;
       /** ID for the global visiblity switch for color wash visualization.  */
       static const std::string GLOBAL_VISIBILITY_COLORWASH_ID;
       /** ID for the selected iso preset that should be used (value of ROOT_ISO_PRESETS_PREFERENCE_NODE_ID + value of this key can
       be used to construct the passed to the selected preset.  */
       static const std::string SELECTED_ISO_PRESET_ID;
 
       /** ID for the relative dose value of an iso dose level.  */
       static const std::string ISO_LEVEL_DOSE_VALUE_ID;
       /** ID for the color (red component) of an iso dose level.  */
       static const std::string ISO_LEVEL_COLOR_RED_ID;
       /** ID for the color (green component) of an iso dose level.  */
       static const std::string ISO_LEVEL_COLOR_GREEN_ID;
       /** ID for the color (blue component) of an iso dose level.  */
       static const std::string ISO_LEVEL_COLOR_BLUE_ID;
       /** ID for the visiblity switch for iso line visualization.  */
       static const std::string ISO_LEVEL_VISIBILITY_ISOLINES_ID;
       /** ID for the visiblity switch for color wash visualization.  */
       static const std::string ISO_LEVEL_VISIBILITY_COLORWASH_ID;
 
       /** Default value used as reference_dose_if not defined by application or data node*/
       static const DoseValueAbs DEFAULT_REFERENCE_DOSE_VALUE;
     };
 
-    struct RTUI_EXPORT CTKEventConstants
+    struct MitkRTUI_EXPORT CTKEventConstants
     {
       /** ID/Path of main preference node for RT UI.  */
       static const std::string TOPIC_REFERENCE_DOSE;
       static const std::string TOPIC_REFERENCE_DOSE_CHANGED;
       static const std::string TOPIC_ISO_DOSE_LEVEL_PRESETS;
       static const std::string TOPIC_ISO_DOSE_LEVEL_PRESETS_CHANGED;
     };
 
   }
 }
 
 #endif
diff --git a/Modules/RTUI/Qmitk/QmitkDoseColorDelegate.h b/Modules/RTUI/Qmitk/QmitkDoseColorDelegate.h
index f4e9663a80..78f027f81b 100644
--- a/Modules/RTUI/Qmitk/QmitkDoseColorDelegate.h
+++ b/Modules/RTUI/Qmitk/QmitkDoseColorDelegate.h
@@ -1,44 +1,44 @@
 /*===================================================================
 
 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 QmitkDoseColorDelegate_h
 #define QmitkDoseColorDelegate_h
 
 
 #include <QStyledItemDelegate>
 
-#include "RTUIExports.h"
+#include "MitkRTUIExports.h"
 
 /** \class QmitkDoseColorDelegate
 \brief An item delegate for rendering and editing dose color in a QTableView.*/
-class RTUI_EXPORT QmitkDoseColorDelegate : public QStyledItemDelegate
+class MitkRTUI_EXPORT QmitkDoseColorDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
   ///
   /// Creates a new PropertyDelegate.
   ///
   QmitkDoseColorDelegate(QObject *parent = 0);
 
   bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option,
     const QModelIndex &index);
 
   void paint(QPainter *painter, const QStyleOptionViewItem &option,
     const QModelIndex &index) const;
 };
 
 #endif
diff --git a/Modules/RTUI/Qmitk/QmitkDoseValueDelegate.h b/Modules/RTUI/Qmitk/QmitkDoseValueDelegate.h
index 711b536170..5116d84c62 100644
--- a/Modules/RTUI/Qmitk/QmitkDoseValueDelegate.h
+++ b/Modules/RTUI/Qmitk/QmitkDoseValueDelegate.h
@@ -1,63 +1,63 @@
 /*===================================================================
 
 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 QmitkDoseValueDelegate_h
 #define QmitkDoseValueDelegate_h
 
 
 #include <QStyledItemDelegate>
 
-#include "RTUIExports.h"
+#include "MitkRTUIExports.h"
 
 /** \class QmitkDoseValueDelegate
 \brief An item delegate for rendering and editing dose values.
 The delegate assumes that the model uses the role Qt::UserRole+1
 to indicate if the returned dose value is an absolute (data(Qt::UserRole+1) == true)
 or an relative dose (data(Qt::UserRole+1) == false).*/
-class RTUI_EXPORT QmitkDoseValueDelegate : public QStyledItemDelegate
+class MitkRTUI_EXPORT QmitkDoseValueDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
   ///
   /// Creates a new PropertyDelegate.
   ///
   QmitkDoseValueDelegate(QObject *parent = 0);
 
   ///
   /// Renders a specific property  (overwritten from QItemDelegate)
   ///
   void paint(QPainter *painter, const QStyleOptionViewItem &option
     , const QModelIndex &index) const;
 
   ///
   /// Create an editor for a specific property  (overwritten from QItemDelegate)
   ///
   QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option
     , const QModelIndex &index) const;
 
   ///
   /// Create an editor for a specific property  (overwritten from QItemDelegate)
   ///
   void setEditorData(QWidget *editor, const QModelIndex &index) const;
 
   ///
   /// When the user accepts input this func commits the data to the model  (overwritten from QItemDelegate)
   ///
   void setModelData(QWidget *editor, QAbstractItemModel* model, const QModelIndex &index) const;
 };
 
 #endif /* QMITKPROPERTIESTABLEMODEL_H_ */
diff --git a/Modules/RTUI/Qmitk/QmitkDoseVisualStyleDelegate.h b/Modules/RTUI/Qmitk/QmitkDoseVisualStyleDelegate.h
index 6ee24667c8..7032fd11d0 100644
--- a/Modules/RTUI/Qmitk/QmitkDoseVisualStyleDelegate.h
+++ b/Modules/RTUI/Qmitk/QmitkDoseVisualStyleDelegate.h
@@ -1,47 +1,47 @@
 /*===================================================================
 
 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 QmitkDoseVisualStyleDelegate_h
 #define QmitkDoseVisualStyleDelegate_h
 
 
 /// Toolkit includes.
 #include <QStyledItemDelegate>
 
-#include "RTUIExports.h"
+#include "MitkRTUIExports.h"
 
 
 /** \class QmitkDoseVisualStyleDelegate
 \brief An item delegate for rendering and editing dose visualization options.
 The delegate is used to handle aspects of a isodose level like visualization
 of the isodose lines or colorwash display.*/
-class RTUI_EXPORT QmitkDoseVisualStyleDelegate : public QStyledItemDelegate
+class MitkRTUI_EXPORT QmitkDoseVisualStyleDelegate : public QStyledItemDelegate
 {
   Q_OBJECT
 
 public:
 
   QmitkDoseVisualStyleDelegate(QObject *parent = 0);
 
   void paint(QPainter *painter, const QStyleOptionViewItem &option
     , const QModelIndex &index) const;
 
   bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option,
     const QModelIndex &index);
 
 };
 
 #endif
diff --git a/Modules/RTUI/Qmitk/QmitkFreeIsoDoseLevelWidget.h b/Modules/RTUI/Qmitk/QmitkFreeIsoDoseLevelWidget.h
index daf3a6d421..8973071578 100644
--- a/Modules/RTUI/Qmitk/QmitkFreeIsoDoseLevelWidget.h
+++ b/Modules/RTUI/Qmitk/QmitkFreeIsoDoseLevelWidget.h
@@ -1,78 +1,78 @@
 /*===================================================================
 
 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 QMITK_FREE_ISO_DOSE_LEVEL_WIDGET_H
 #define QMITK_FREE_ISO_DOSE_LEVEL_WIDGET_H
 
-#include "RTUIExports.h"
+#include "MitkRTUIExports.h"
 
 #include "ui_QmitkFreeIsoDoseLevelWidget.h"
 #include <QWidget>
 
 #include "mitkIsoDoseLevel.h"
 
 /**
 * \class QmitkFreeIsoDoseLevelWidget
 * \brief Widget that allows to show and edit the content of an mitk::IsoDoseLevel instance.
 */
-class RTUI_EXPORT QmitkFreeIsoDoseLevelWidget : public QWidget, private Ui::QmitkFreeIsoDoseLevelWidget
+class MitkRTUI_EXPORT QmitkFreeIsoDoseLevelWidget : public QWidget, private Ui::QmitkFreeIsoDoseLevelWidget
 {
   Q_OBJECT
 
 public:
   QmitkFreeIsoDoseLevelWidget(QWidget* parent=0);
 
   mitk::DoseValueAbs getReferenceDose() const;
   mitk::IsoDoseLevel* getIsoDoseLevel() const;
 
 signals:
   void ValueChanged(mitk::IsoDoseLevel*, mitk::DoseValueRel oldValue);
   void ColorChanged(mitk::IsoDoseLevel*);
   void VisualizationStyleChanged(mitk::IsoDoseLevel*);
 
   public Q_SLOTS:
     /**
     * \brief Slot that can be used to set the reference dose.
     */
     void setReferenceDose(double newReferenceDose);
 
     /**
     * \brief Slot that can be used to set the dose level instance that should be handled by the widget.
     */
     void setIsoDoseLevel(mitk::IsoDoseLevel* level);
 
     void OnRelValueChanged(double newValue);
     void OnAbsValueChanged(double newValue);
     void OnSliderChanged(int newValue);
     void OnVisibleClicked(bool checked);
     void OnColorChanged(QColor color);
 
 protected:
 
   /**
   * \brief Updates the widget according to its current settings.
   */
   void update();
   void updateValue(mitk::DoseValueRel newDose);
 
   mitk::DoseValueAbs m_ReferenceDose;
   mitk::IsoDoseLevel::Pointer m_IsoDoseLevel;
   bool m_InternalUpdate;
 
 };
 
 #endif // QmitkFreeIsoDoseLevelWidget_H
diff --git a/Modules/RTUI/Qmitk/QmitkIsoDoseLevelSetModel.h b/Modules/RTUI/Qmitk/QmitkIsoDoseLevelSetModel.h
index b74ebef576..0940072072 100644
--- a/Modules/RTUI/Qmitk/QmitkIsoDoseLevelSetModel.h
+++ b/Modules/RTUI/Qmitk/QmitkIsoDoseLevelSetModel.h
@@ -1,98 +1,98 @@
 /*===================================================================
 
 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 QmitkIsoDoseLevelSetModel_h
 #define QmitkIsoDoseLevelSetModel_h
 
 #include <QAbstractTableModel>
 
 #include "mitkIsoDoseLevelCollections.h"
 
-#include "RTUIExports.h"
+#include "MitkRTUIExports.h"
 
 
 /*!
 \class QmitkIsoDoseLevelSetModel
 Model that handles a iso dose level set and allows viewing and editing of its contents.
 Please see special delegates (QmitkDoseColorDelegate, QmitkDoseValueDelegate, QmitkDoseVisualStyleDelegate) to
 handle visualization and editing in views that work on this model.
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 */
-class RTUI_EXPORT QmitkIsoDoseLevelSetModel : public QAbstractTableModel
+class MitkRTUI_EXPORT QmitkIsoDoseLevelSetModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
   QmitkIsoDoseLevelSetModel(QObject *parent = NULL);
   virtual ~QmitkIsoDoseLevelSetModel() {};
 
   /** Sets the data handled by the model and resets the modified flag*/
   void setIsoDoseLevelSet(mitk::IsoDoseLevelSet *pSet);
 
   virtual Qt::ItemFlags flags(const QModelIndex &index) const;
   virtual QVariant data(const QModelIndex &index, int role) const;
   virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const;
   virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
   virtual int columnCount(const QModelIndex &parent = QModelIndex()) const;
   virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
 
   bool getShowAbsoluteDose() const;
   mitk::DoseValueAbs getReferenceDose() const;
 
   bool getVisibilityEditOnly() const;
 
   void switchVisibilityIsoLines(bool activate);
   void switchVisibilityColorWash(bool activate);
   void invertVisibilityIsoLines();
   void invertVisibilityColorWash();
   void swapVisibility();
 
   void addLevel();
   void deleteLevel(const QModelIndex &index);
 
   /**Indicates if the content of the model was modified since the data was set via setIsoDoseLevelSet()*/
   bool isModified();
 
   public Q_SLOTS:
     /**
     * \brief Slot that can be used to set the prescribed dose.
     */
     void setReferenceDose(double newReferenceDose);
     /**
     * \brief Slot that can be used to adjust whether the dose should be displayed in absolute or relative units.
     */
     void setShowAbsoluteDose(bool showAbsoluteDose);
 
     /**
     * \brief Slat that can be used to adjust wether the model allows to edit only visibilities (no dose value or color)
     */
     void setVisibilityEditOnly(bool onlyVisibility);
 
 private:
   mitk::IsoDoseLevelSet::Pointer m_DoseSet;
 
   bool m_showAbsoluteDose;
   bool m_visibilityEditOnly;
 
   mitk::DoseValueAbs m_referenceDose;
 
   /** Indicates if the data of the model was modified, since the model was set. */
   bool m_modified;
 
 };
 
 #endif // QmitkIsoDoseLevelSetModel_h
 
diff --git a/Plugins/org.mitk.gui.qt.rt.dosevisualization/CMakeLists.txt b/Plugins/org.mitk.gui.qt.rt.dosevisualization/CMakeLists.txt
index 9a86aaa7a2..243c436059 100644
--- a/Plugins/org.mitk.gui.qt.rt.dosevisualization/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.rt.dosevisualization/CMakeLists.txt
@@ -1,7 +1,7 @@
 project(org_mitk_gui_qt_rt_dosevisualization)
 
 MACRO_CREATE_MITK_CTK_PLUGIN(
   EXPORT_DIRECTIVE RTDOSEVISUALIZATION_EXPORT
   EXPORTED_INCLUDE_SUFFIXES src
-  MODULE_DEPENDENCIES QmitkExt mitkDicomRT RTUI
+  MODULE_DEPENDS MitkQtWidgetsExt MitkDicomRT MitkRTUI
 )
diff --git a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/LoadingRTView.cpp b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/LoadingRTView.cpp
index d57b173c73..d71835d061 100644
--- a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/LoadingRTView.cpp
+++ b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/LoadingRTView.cpp
@@ -1,131 +1,131 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "LoadingRTView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 
 #include <mitkDicomRTReader.h>
 
 const std::string LoadingRTView::VIEW_ID = "org.mitk.views.loadingrtview";
 
 void LoadingRTView::SetFocus(){}
 
 void LoadingRTView::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
   connect( m_Controls.btnLoadStruct, SIGNAL(clicked()), this, SLOT(LoadRTStructureSet()) );
   connect( m_Controls.btnLoadDose, SIGNAL(clicked()), this, SLOT(LoadRTDoseFile()) );
 }
 
 void LoadingRTView::LoadRTStructureSet()
 {
   QFileDialog dialog;
   dialog.setNameFilter(tr("Images (*.dcm"));
 
   mitk::DicomSeriesReader::StringContainer files;
   QStringList fileNames = dialog.getOpenFileNames();
   if(fileNames.empty())
   {
     return;
   }
   QStringListIterator fileNamesIterator(fileNames);
   while(fileNamesIterator.hasNext())
   {
     files.push_back(fileNamesIterator.next().toStdString());
   }
 
   std::string tmp = files.front();
   const char* filename = tmp.c_str();
   char* filenameC = const_cast<char*>(filename);
 
   DcmFileFormat file;
   OFCondition outp = file.loadFile(filename, EXS_Unknown);
   if(outp.bad())
   {
     QMessageBox::information(NULL,"Error","Cant read the file");
   }
   DcmDataset *dataset = file.getDataset();
 
   mitk::DicomRTReader::Pointer readerRT = mitk::DicomRTReader::New();
   std::deque<mitk::ContourModelSet::Pointer> modelVector;
   modelVector = readerRT->ReadDicomFile(filenameC);
 
   if(modelVector.empty())
   {
     QMessageBox::information(NULL, "Error", "Vector is empty ...");
   }
 
   for(int i=0; i<modelVector.size();i++)
   {
     mitk::DataNode::Pointer x = mitk::DataNode::New();
     x->SetData(modelVector.at(i));
     x->SetProperty("name", modelVector.at(i)->GetProperty("name"));
     x->SetVisibility(true);
     GetDataStorage()->Add(x);
   }
-  mitk::TimeSlicedGeometry::Pointer geo = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
+  mitk::TimeGeometry::Pointer geo = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews( geo );
 }
 
 void LoadingRTView::LoadRTDoseFile()
 {
   QFileDialog dialog;
   dialog.setNameFilter(tr("Images (*.dcm"));
 
   mitk::DicomSeriesReader::StringContainer files;
   QStringList fileNames = dialog.getOpenFileNames();
   if(fileNames.empty())
   {
     return;
   }
   QStringListIterator fileNamesIterator(fileNames);
   while(fileNamesIterator.hasNext())
   {
     files.push_back(fileNamesIterator.next().toStdString());
   }
 
   std::string tmp = files.front();
   const char* filename = tmp.c_str();
   char* ncFilename = const_cast<char*>(filename);
 
   mitk::DicomRTReader::Pointer _DicomRTReader = mitk::DicomRTReader::New();
 
   DcmFileFormat file;
   OFCondition outp = file.loadFile(filename, EXS_Unknown);
   if(outp.bad())
   {
     QMessageBox::information(NULL,"Error","Cant read the file");
   }
   DcmDataset *dataset = file.getDataset();
 
   mitk::DataNode::Pointer mitkImage = mitk::DataNode::New();
   mitkImage = _DicomRTReader->LoadRTDose(dataset,ncFilename);
 
   GetDataStorage()->Add(mitkImage);
 
-  mitk::TimeSlicedGeometry::Pointer geo3 = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
+  mitk::TimeGeometry::Pointer geo3 = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews( geo3 );
 }
diff --git a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp
index 9a0cae2a7b..5d80d7111d 100644
--- a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp
+++ b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp
@@ -1,807 +1,807 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Qt
 #include <QMessageBox>
 #include <QMenu>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 
 #include <service/event/ctkEventAdmin.h>
 #include <service/event/ctkEventConstants.h>
 
 // Qmitk
 #include "RTDoseVisualizer.h"
 
 #include <DataStructures/mitkRTConstants.h>
 #include <DataStructures/mitkIsoDoseLevelSetProperty.h>
 #include <DataStructures/mitkIsoDoseLevelVectorProperty.h>
 #include <mitkIsoLevelsGenerator.h>
 #include <mitkRTUIConstants.h>
 
 #include <QmitkDoseColorDelegate.h>
 #include <QmitkDoseValueDelegate.h>
 #include <QmitkDoseVisualStyleDelegate.h>
 #include <QmitkIsoDoseLevelSetModel.h>
 #include <QmitkFreeIsoDoseLevelWidget.h>
 
 #include "org_mitk_gui_qt_rt_dosevisualization_Activator.h"
 
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <vtkMath.h>
 
 #include <vtkMarchingSquares.h>
 #include <mitkSurface.h>
 #include "QmitkRenderWindow.h"
 #include <mitkExtractSliceFilter.h>
 
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkPolyDataGLMapper2D.h"
 #include "mitkSurfaceVtkMapper3D.h"
 
 #include "mitkSliceNavigationController.h"
 
 const std::string RTDoseVisualizer::VIEW_ID = "org.mitk.views.rt.dosevisualization";
 
 RTDoseVisualizer::RTDoseVisualizer()
 {
     m_freeIsoValues = mitk::IsoDoseLevelVector::New();
     m_selectedNodeIsoSet = mitk::IsoDoseLevelSet::New();
 
     m_freeIsoFilter = vtkSmartPointer<vtkContourFilter>::New();
 
     m_selectedNode = NULL;
     m_selectedPresetName = "";
     m_internalUpdate = false;
     m_PrescribedDose_Data = 0.0;
 
     //hier crash ?!
 //    QmitkRenderWindow* rw = this->GetRenderWindowPart()->GetQmitkRenderWindow(name);
 
 //    itk::MemberCommand<RTDoseVisualizer>::Pointer sliceChangedCommand =
 //        itk::MemberCommand<RTDoseVisualizer>::New();
 //    sliceChangedCommand->SetCallbackFunction(this, &RTDoseVisualizer::OnSliceChanged);
 //    rw->GetSliceNavigationController()->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(NULL,0), sliceChangedCommand);
 
 //    mitk::CoreServicePointer<mitk::IShaderRepository> shadoRepo(mitk::CoreServices::GetShaderRepository());
 //    std::string path = "/home/riecker/mitkShaderLighting.xml";
 //    std::string isoShaderName = "mitkIsoLineShader";
 //    MITK_INFO << "shader found under: " << path;
 //    std::ifstream str(path.c_str());
 //    shadoRepo->LoadShader(str,isoShaderName);
 }
 
 RTDoseVisualizer::~RTDoseVisualizer()
 {
   delete m_LevelSetModel;
   delete m_DoseColorDelegate;
   delete m_DoseValueDelegate;
   delete m_DoseVisualDelegate;
 }
 
 void RTDoseVisualizer::InitScrolling(){
   QmitkRenderWindow* rw = this->GetRenderWindowPart()->GetQmitkRenderWindow("axial");
 
       itk::MemberCommand<RTDoseVisualizer>::Pointer sliceChangedCommand =
           itk::MemberCommand<RTDoseVisualizer>::New();
       sliceChangedCommand->SetCallbackFunction(this, &RTDoseVisualizer::OnSliceChanged);
       rw->GetSliceNavigationController()->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(NULL,0), sliceChangedCommand);
 }
 
 void RTDoseVisualizer::SetFocus()
 {
 }
 
 void RTDoseVisualizer::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
 {
   for(int i=0; i<m_StdIsoLines.size();++i)
   {
     GetDataStorage()->Remove(m_StdIsoLines.at(i));
   }
   m_StdIsoLines.clear();
   this->UpdateStdIsolines();
 }
 
 void RTDoseVisualizer::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   m_LevelSetModel = new QmitkIsoDoseLevelSetModel(this);
   m_LevelSetModel->setVisibilityEditOnly(true);
   m_DoseColorDelegate = new QmitkDoseColorDelegate(this);
   m_DoseValueDelegate = new QmitkDoseValueDelegate(this);
   m_DoseVisualDelegate = new QmitkDoseVisualStyleDelegate(this);
 
   this->UpdateByPreferences();
   this->ActualizeIsoLevelsForAllDoseDataNodes();
   this->ActualizeReferenceDoseForAllDoseDataNodes();
   this->ActualizeDisplayStyleForAllDoseDataNodes();
 
   this->m_Controls.isoLevelSetView->setModel(m_LevelSetModel);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(0,m_DoseColorDelegate);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(1,m_DoseValueDelegate);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(2,m_DoseVisualDelegate);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(3,m_DoseVisualDelegate);
   this->m_Controls.isoLevelSetView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   this->m_Controls.btnRemoveFreeValue->setDisabled(true);
 
   connect(m_Controls.btnConvert, SIGNAL(clicked()), this, SLOT(OnConvertButtonClicked()));
   connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), this, SLOT(OnReferenceDoseChanged(double)));
   connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), m_LevelSetModel, SLOT(setReferenceDose(double)));
   connect(m_Controls.radioAbsDose, SIGNAL(toggled(bool)), m_LevelSetModel, SLOT(setShowAbsoluteDose(bool)));
   connect(m_Controls.radioAbsDose, SIGNAL(toggled(bool)), this, SLOT(OnAbsDoseToggled(bool)));
   connect(m_Controls.btnAddFreeValue, SIGNAL(clicked()), this, SLOT(OnAddFreeValueClicked()));
   connect(m_Controls.btnRemoveFreeValue, SIGNAL(clicked()), this, SLOT(OnRemoveFreeValueClicked()));
   connect(m_Controls.checkGlobalVisColorWash, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisColorWashToggled(bool)));
   connect(m_Controls.checkGlobalVisIsoLine, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisIsoLineToggled(bool)));
   connect(m_Controls.isoLevelSetView, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnShowContextMenuIsoSet(const QPoint&)));
   connect(m_Controls.comboPresets, SIGNAL(currentIndexChanged ( const QString&)), this, SLOT(OnCurrentPresetChanged(const QString&)));
   connect(m_Controls.btnUsePrescribedDose, SIGNAL(clicked()), this, SLOT(OnUsePrescribedDoseClicked()));
 
   ctkServiceReference ref = mitk::org_mitk_gui_qt_rt_dosevisualization_Activator::GetContext()->getServiceReference<ctkEventAdmin>();
 
   ctkDictionary propsForSlot;
   if (ref)
   {
     ctkEventAdmin* eventAdmin = mitk::org_mitk_gui_qt_rt_dosevisualization_Activator::GetContext()->getService<ctkEventAdmin>(ref);
 
     propsForSlot[ctkEventConstants::EVENT_TOPIC] = mitk::rt::CTKEventConstants::TOPIC_ISO_DOSE_LEVEL_PRESETS_CHANGED.c_str();
     eventAdmin->subscribeSlot(this, SLOT(OnHandleCTKEventPresetsChanged(ctkEvent)), propsForSlot);
 
     propsForSlot[ctkEventConstants::EVENT_TOPIC] = mitk::rt::CTKEventConstants::TOPIC_REFERENCE_DOSE_CHANGED.c_str();
     eventAdmin->subscribeSlot(this, SLOT(OnHandleCTKEventReferenceDoseChanged(ctkEvent)), propsForSlot);
   }
 
   this->UpdateBySelectedNode();
 }
 
 void RTDoseVisualizer::OnReferenceDoseChanged(double value)
 {
   if (!  m_internalUpdate)
   {
     mitk::DoseValueAbs referenceDose = 0.0;
     bool globalSync = mitk::rt::GetReferenceDoseValue(referenceDose);
 
     if (globalSync)
     {
       mitk::rt::SetReferenceDoseValue(globalSync, value);
       this->ActualizeReferenceDoseForAllDoseDataNodes();
     }
     else
     {
       if (this->m_selectedNode.IsNotNull())
       {
         this->m_selectedNode->SetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
       }
     }
     if (this->m_selectedNode.IsNotNull())
     {
       mitk::TransferFunction::ControlPoints scalarOpacityPoints;
       scalarOpacityPoints.push_back( std::make_pair(0, 1 ) );
       vtkSmartPointer<vtkColorTransferFunction> transferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
       mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = this->m_Presets[this->m_selectedPresetName];
       for(mitk::IsoDoseLevelSet::ConstIterator setIT = isoDoseLevelSet->Begin(); setIT != isoDoseLevelSet->End(); ++setIT)
       {
         float *hsv = new float[3];
         vtkSmartPointer<vtkMath> cCalc = vtkSmartPointer<vtkMath>::New();
         if(setIT->GetVisibleColorWash()){
           cCalc->RGBToHSV(setIT->GetColor()[0],setIT->GetColor()[1],setIT->GetColor()[2],&hsv[0],&hsv[1],&hsv[2]);
           transferFunction->AddHSVPoint(setIT->GetDoseValue()*value,hsv[0],hsv[1],hsv[2],1.0,1.0);
         }
         else
         {
           scalarOpacityPoints.push_back( std::make_pair(setIT->GetDoseValue()*value, 1 ) );
         }
       }
       mitk::TransferFunction::Pointer mitkTransFunc = mitk::TransferFunction::New();
       mitk::TransferFunctionProperty::Pointer mitkTransFuncProp = mitk::TransferFunctionProperty::New();
       mitkTransFunc->SetColorTransferFunction(transferFunction);
       mitkTransFunc->SetScalarOpacityPoints(scalarOpacityPoints);
       mitkTransFuncProp->SetValue(mitkTransFunc);
 
       mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
       renderingMode->SetValue(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
       m_selectedNode->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
       m_selectedNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
-      mitk::TimeSlicedGeometry::Pointer geo3 = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
+      mitk::TimeGeometry::Pointer geo3 = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
       mitk::RenderingManager::GetInstance()->InitializeViews( geo3 );
     }
   }
 }
 
 void RTDoseVisualizer::OnAddFreeValueClicked()
 {
   QColor newColor;
   //Use HSV schema of QColor to calculate a different color depending on the
   //number of already existing free iso lines.
   newColor.setHsv((m_freeIsoValues->Size()*85)%360,255,255);
 
   mitk::DataNode::Pointer isoNode = this->UpdatePolyData(1,m_Controls.spinReferenceDose->value()*0.5,m_Controls.spinReferenceDose->value()*0.5);
   m_FreeIsoLines.push_back(isoNode);
 
   mitk::IsoDoseLevel::ColorType color;
   color[0] = newColor.redF();
   color[1] = newColor.greenF();
   color[2] = newColor.blueF();
   m_freeIsoValues->push_back(mitk::IsoDoseLevel::New(0.5,color,true,false));
   UpdateFreeIsoValues();
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   if(m_FreeIsoLines.size()>=3)
     this->m_Controls.btnAddFreeValue->setDisabled(true);
   this->m_Controls.btnRemoveFreeValue->setEnabled(true);
 }
 
 void RTDoseVisualizer::OnRemoveFreeValueClicked()
 {
   m_freeIsoValues->pop_back();
   mitk::DataNode::Pointer isoNode = m_FreeIsoLines.at(m_FreeIsoLines.size()-1);
   m_FreeIsoLines.pop_back();
   m_Filters.pop_back();
   if(m_FreeIsoLines.empty())
     this->m_Controls.btnRemoveFreeValue->setDisabled(true);
   if(m_FreeIsoLines.size()<3)
     this->m_Controls.btnAddFreeValue->setEnabled(true);
   this->GetDataStorage()->Remove(isoNode);
   UpdateFreeIsoValues();
 }
 
 void RTDoseVisualizer::OnUsePrescribedDoseClicked()
 {
   m_Controls.spinReferenceDose->setValue(this->m_PrescribedDose_Data);
 };
 
 
 void RTDoseVisualizer::OnShowContextMenuIsoSet(const QPoint& pos)
 {
   QPoint globalPos = m_Controls.isoLevelSetView->viewport()->mapToGlobal(pos);
 
   QMenu viewMenu;
   QAction* invertIsoLineAct = viewMenu.addAction("Invert iso line visibility");
   QAction* activateIsoLineAct = viewMenu.addAction("Activate all iso lines");
   QAction* deactivateIsoLineAct = viewMenu.addAction("Deactivate all iso lines");
   viewMenu.addSeparator();
   QAction* invertColorWashAct = viewMenu.addAction("Invert color wash visibility");
   QAction* activateColorWashAct = viewMenu.addAction("Activate all color wash levels");
   QAction* deactivateColorWashAct = viewMenu.addAction("Deactivate all color wash levels");
   viewMenu.addSeparator();
   QAction* swapAct = viewMenu.addAction("Swap iso line/color wash visibility");
   // ...
 
   QAction* selectedItem = viewMenu.exec(globalPos);
   if (selectedItem == invertIsoLineAct)
   {
     this->m_LevelSetModel->invertVisibilityIsoLines();
   }
   else if (selectedItem == activateIsoLineAct)
   {
     this->m_LevelSetModel->switchVisibilityIsoLines(true);
   }
   else if (selectedItem == deactivateIsoLineAct)
   {
     this->m_LevelSetModel->switchVisibilityIsoLines(false);
   }
   else if (selectedItem == invertColorWashAct)
   {
     this->m_LevelSetModel->invertVisibilityColorWash();
   }
   else if (selectedItem == activateColorWashAct)
   {
     this->m_LevelSetModel->switchVisibilityColorWash(true);
   }
   else if (selectedItem == deactivateColorWashAct)
   {
     this->m_LevelSetModel->switchVisibilityColorWash(false);
   }
   else if (selectedItem == swapAct)
   {
     this->m_LevelSetModel->swapVisibility();
   }
 }
 
 void RTDoseVisualizer::UpdateFreeIsoValues()
 {
   this->m_Controls.listFreeValues->clear();
 
   for (mitk::IsoDoseLevelVector::Iterator pos = this->m_freeIsoValues->Begin(); pos != this->m_freeIsoValues->End(); ++pos)
   {
     QListWidgetItem* item = new QListWidgetItem;
     item->setSizeHint(QSize(0,25));
     QmitkFreeIsoDoseLevelWidget* widget = new QmitkFreeIsoDoseLevelWidget;
 
     float pref;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
 
     widget->setIsoDoseLevel(pos->Value().GetPointer());
     widget->setReferenceDose(pref);
     connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), widget, SLOT(setReferenceDose(double)));
     connect(widget,SIGNAL(ValueChanged(mitk::IsoDoseLevel*,mitk::DoseValueRel)), this, SLOT(UpdateFreeIsoLine(mitk::IsoDoseLevel*,mitk::DoseValueRel)));
 
     this->m_Controls.listFreeValues->addItem(item);
     this->m_Controls.listFreeValues->setItemWidget(item,widget);
   }
 }
 
 void RTDoseVisualizer::UpdateFreeIsoLine(mitk::IsoDoseLevel * level, mitk::DoseValueRel old)
 {
   float pref;
   m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
   mitk::Image::Pointer slicedImage = this->GetExtractedSlice(image);
 
-  m_Filters.at(0)->SetInput(slicedImage->GetVtkImageData());
+  m_Filters.at(0)->SetInputData(slicedImage->GetVtkImageData());
   m_Filters.at(0)->GenerateValues(1,level->GetDoseValue()*pref,level->GetDoseValue()*pref);
   m_Filters.at(0)->Update();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void RTDoseVisualizer::OnAbsDoseToggled(bool showAbs)
 {
   if (!  m_internalUpdate)
   {
     mitk::rt::SetDoseDisplayAbsolute(showAbs);
     this->ActualizeDisplayStyleForAllDoseDataNodes();
   }
 }
 
 void RTDoseVisualizer::OnGlobalVisColorWashToggled(bool showColorWash)
 {
   if (m_selectedNode.IsNotNull())
   {
     m_selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(), showColorWash);
   }
 }
 
 void RTDoseVisualizer::OnGlobalVisIsoLineToggled(bool showIsoLines)
 {
   if (m_selectedNode.IsNotNull())
   {
     m_selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), showIsoLines);
     mitk::NodePredicateProperty::Pointer isoProp = mitk::NodePredicateProperty::
         New(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
     mitk::DataStorage::SetOfObjects::ConstPointer isoSet =  this->GetDataStorage()->GetSubset(isoProp);
     for(mitk::DataStorage::SetOfObjects::ConstIterator iso = isoSet->Begin(); iso!=isoSet->End(); ++iso)
     {
       mitk::DataNode::Pointer node = iso.Value();
       node->SetVisibility(showIsoLines);
     }
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 
 void RTDoseVisualizer::OnConvertButtonClicked()
 {
   this->InitScrolling();
 
   QList<mitk::DataNode::Pointer> dataNodes = this->GetDataManagerSelection();
 
   mitk::DataNode* selectedNode = NULL;
 
   if (!dataNodes.empty())
   {
     selectedNode = dataNodes[0];
   }
 
   if(selectedNode)
   {
     selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(), true);
     selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(), true);
     selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), true);
     selectedNode->SetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), m_Controls.spinReferenceDose->value());
 
     //selectedNode->GetData()->SetProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(), mitk::DoubleProperty::New(1.0));
 
     mitk::IsoDoseLevelSet::Pointer clonedPreset = this->m_Presets[this->m_selectedPresetName]->Clone();
     mitk::IsoDoseLevelSetProperty::Pointer levelSetProp = mitk::IsoDoseLevelSetProperty::New(clonedPreset);
     selectedNode->SetProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),levelSetProp);
 
 
     double hsvValue = 0.002778;
     float prescribed;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(),prescribed);
 
     vtkSmartPointer<vtkColorTransferFunction> transferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
 
     mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = this->m_Presets[this->m_selectedPresetName];
 
     MITK_INFO << "FUNCTION PRESCRIBE " << prescribed << endl;
 
 
     float pref;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     mitk::Image::Pointer reslicedImage = this->GetExtractedSlice(image);
 
     //Generating the Colorwash
     for(mitk::IsoDoseLevelSet::ConstIterator setIT = isoDoseLevelSet->Begin(); setIT != isoDoseLevelSet->End(); ++setIT)
     {
       float *hsv = new float[3];
       //used for transfer rgb to hsv
       vtkSmartPointer<vtkMath> cCalc = vtkSmartPointer<vtkMath>::New();
       if(setIT->GetVisibleColorWash()){
         cCalc->RGBToHSV(setIT->GetColor()[0],setIT->GetColor()[1],setIT->GetColor()[2],&hsv[0],&hsv[1],&hsv[2]);
         transferFunction->AddHSVPoint(setIT->GetDoseValue()*pref,hsv[0],hsv[1],hsv[2],1.0,1.0);
       }
     }
 
     //Generating the standard isolines
     this->UpdateStdIsolines();
 
     mitk::TransferFunction::Pointer mitkTransFunc = mitk::TransferFunction::New();
     mitk::TransferFunctionProperty::Pointer mitkTransFuncProp = mitk::TransferFunctionProperty::New();
     mitkTransFunc->SetColorTransferFunction(transferFunction);
     mitkTransFuncProp->SetValue(mitkTransFunc);
 
     mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
     renderingMode->SetValue(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
     selectedNode->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
     selectedNode->SetProperty("Image Rendering.Mode", renderingMode);
     m_selectedNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
     mitk::IsoDoseLevelVector::Pointer levelVector = mitk::IsoDoseLevelVector::New();
     mitk::IsoDoseLevelVectorProperty::Pointer levelVecProp = mitk::IsoDoseLevelVectorProperty::New(levelVector);
     selectedNode->SetProperty(mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),levelVecProp);
 
     UpdateBySelectedNode();
 
 //    mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
 //    renderingMode->SetValue(mitk::RenderingModeProperty::ISODOSESHADER_COLOR);
 //    selectedNode->SetProperty("shader.mitkIsoLineShader.Gridscale", mitk::FloatProperty::New(10.0));
 //    selectedNode->SetProperty("Image Rendering.Mode", renderingMode);
 
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 //######################################################################################################
 const mitk::Geometry2D* RTDoseVisualizer::GetGeometry2D(char* dim)
 {
   QmitkRenderWindow* rw = this->GetRenderWindowPart()->GetQmitkRenderWindow(dim);
   const mitk::Geometry2D* worldGeo = rw->GetRenderer()->GetCurrentWorldGeometry2D();
   return worldGeo;
 }
 
 mitk::Image::Pointer RTDoseVisualizer::GetExtractedSlice(mitk::Image::Pointer image)
 {
   mitk::ExtractSliceFilter::Pointer extractFilter = mitk::ExtractSliceFilter::New();
   extractFilter->SetInput(image);
   extractFilter->SetWorldGeometry(this->GetGeometry2D("axial"));
   extractFilter->SetResliceTransformByGeometry( image->GetGeometry() );
   extractFilter->Update();
   mitk::Image::Pointer reslicedImage = extractFilter->GetOutput();
   return reslicedImage;
 }
 
 mitk::DataNode::Pointer RTDoseVisualizer::UpdatePolyData(int num, double min, double max)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
   mitk::Image::Pointer reslicedImage = this->GetExtractedSlice(image);
 
   vtkSmartPointer<vtkContourFilter> contourFilter = vtkSmartPointer<vtkContourFilter>::New();
   m_Filters.push_back(contourFilter);
-  contourFilter->SetInput(reslicedImage->GetVtkImageData());
+  contourFilter->SetInputData(reslicedImage->GetVtkImageData());
   contourFilter->GenerateValues(num,min,max);
   contourFilter->Update();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData =contourFilter->GetOutput();
 //  polyData->Print(std::cout);
 
   mitk::Surface::Pointer isoline = mitk::Surface::New();
   isoline->SetVtkPolyData(polyData);
   isoline->SetGeometry(const_cast<mitk::Geometry2D*>(this->GetGeometry2D("axial"))->Clone());
   isoline->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing());
   isoline->SetOrigin(reslicedImage->GetGeometry()->GetOrigin());
 
   mitk::DataNode::Pointer isolineNode = mitk::DataNode::New();
   isolineNode->SetData(isoline);
 //  mitk::PolyDataGLMapper2D::Pointer mapper = mitk::PolyDataGLMapper2D::New();
 //  mitk::SurfaceGLMapper2D::Pointer mapper = mitk::SurfaceGLMapper2D::New();
   mitk::SurfaceVtkMapper3D::Pointer mapper = mitk::SurfaceVtkMapper3D::New();
   isolineNode->SetMapper(1, mapper);
   isolineNode->SetName("Isoline1");
   isolineNode->SetBoolProperty(mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),true);
   this->GetDataStorage()->Add(isolineNode);
   return isolineNode;
 }
 
 void RTDoseVisualizer::UpdateStdIsolines()
 {
   mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = this->m_Presets[this->m_selectedPresetName];
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
   mitk::Image::Pointer reslicedImage = this->GetExtractedSlice(image);
 
   float pref;
   m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
 
   for(mitk::IsoDoseLevelSet::ConstIterator doseIT = isoDoseLevelSet->Begin(); doseIT!=isoDoseLevelSet->End();++doseIT)
   {
     if(doseIT->GetVisibleIsoLine()){
       vtkSmartPointer<vtkContourFilter> isolineFilter = vtkSmartPointer<vtkContourFilter>::New();
-      isolineFilter->SetInput(reslicedImage->GetVtkImageData());
+      isolineFilter->SetInputData(reslicedImage->GetVtkImageData());
       isolineFilter->GenerateValues(1,doseIT->GetDoseValue()*pref,doseIT->GetDoseValue()*pref);
       isolineFilter->Update();
 
       vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
       polyData=isolineFilter->GetOutput();
 
       mitk::Surface::Pointer surface = mitk::Surface::New();
       surface->SetVtkPolyData(polyData);
       surface->SetGeometry(const_cast<mitk::Geometry2D*>(this->GetGeometry2D("axial"))->Clone());
       surface->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing());
       surface->SetOrigin(reslicedImage->GetGeometry()->GetOrigin());
 
       mitk::DataNode::Pointer isoNode = mitk::DataNode::New();
       isoNode->SetData(surface);
       mitk::SurfaceVtkMapper3D::Pointer mapper = mitk::SurfaceVtkMapper3D::New();
       mitk::Color color;
       color[0]=doseIT->GetColor()[0];color[1]=doseIT->GetColor()[1];color[2]=doseIT->GetColor()[2];
       isoNode->SetMapper(1,mapper);
       isoNode->SetColor(color);
       isoNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
       isoNode->SetName("StdIsoline");
       isoNode->SetBoolProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),true);
       m_StdIsoLines.push_back(isoNode);
       this->GetDataStorage()->Add(isoNode);
     }
   }
 }
 
 void RTDoseVisualizer::HideIsoline()
 {
   mitk::NodePredicateProperty::Pointer isoProp = mitk::NodePredicateProperty::
       New(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
   mitk::DataStorage::SetOfObjects::ConstPointer isoSet =  this->GetDataStorage()->GetSubset(isoProp);
   for(mitk::DataStorage::SetOfObjects::ConstIterator iso = isoSet->Begin(); iso!=isoSet->End(); ++iso)
   {
   }
 }
 
 //######################################################################################################
 void RTDoseVisualizer::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,
   const QList<mitk::DataNode::Pointer>& nodes )
 {
   QList<mitk::DataNode::Pointer> dataNodes = this->GetDataManagerSelection();
 
   mitk::DataNode* selectedNode = NULL;
 
   if (!dataNodes.empty())
   {
     bool isDoseNode = false;
     dataNodes[0]->GetBoolProperty(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(),isDoseNode);
 
     if (isDoseNode)
     {
       selectedNode = dataNodes[0];
     }
   }
 
   if (selectedNode != m_selectedNode.GetPointer())
   {
     m_selectedNode = selectedNode;
   }
 
   UpdateBySelectedNode();
 }
 
 void RTDoseVisualizer::UpdateBySelectedNode()
 {
   m_Controls.groupNodeSpecific->setEnabled(m_selectedNode.IsNotNull());
   m_Controls.groupFreeValues->setEnabled(m_selectedNode.IsNotNull());
 
   if(m_selectedNode.IsNull())
   {
     m_Controls.NrOfFractions->setText(QString("N/A. No dose selected"));
     m_Controls.prescribedDoseSpecific->setText(QString("N/A. No dose selected"));
     m_freeIsoValues = mitk::IsoDoseLevelVector::New();
     UpdateFreeIsoValues();
   }
   else
   {
     ///////////////////////////////////////////
     //dose specific information
     int fracCount = 1;
     m_selectedNode->GetIntProperty(mitk::rt::Constants::DOSE_FRACTION_COUNT_PROPERTY_NAME.c_str(),fracCount);
     m_Controls.NrOfFractions->setText(QString::number(fracCount));
 
     m_PrescribedDose_Data = 0.0;
 
     float tmp;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(),tmp);
     m_PrescribedDose_Data = (double)tmp;
 //    dynamic cast von float zu doubleproperty funktioniert nicht & getProperty von node->getData() funktioniert das ?
 //    mitk::DoubleProperty* propDouble = dynamic_cast<mitk::DoubleProperty*>(m_selectedNode->GetData()->GetProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str()).GetPointer());
 //    if (propDouble)
 //    {
 //      m_PrescribedDose_Data = propDouble->GetValue();
 //    }
 
     m_Controls.prescribedDoseSpecific->setText(QString::number(m_PrescribedDose_Data));
 
     ///////////////////////////////////////////
     //free iso lines
     mitk::IsoDoseLevelVectorProperty::Pointer propIsoVector;
     m_selectedNode->GetProperty<mitk::IsoDoseLevelVectorProperty>(propIsoVector, mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str());
 
     if (propIsoVector.IsNull())
     {
       m_freeIsoValues = mitk::IsoDoseLevelVector::New();
       propIsoVector = mitk::IsoDoseLevelVectorProperty::New(m_freeIsoValues);
       m_selectedNode->SetProperty(mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),propIsoVector);
     }
     else
     {
       m_freeIsoValues = propIsoVector->GetValue();
     }
 
     UpdateFreeIsoValues();
 
     ///////////////////////////////////////////
     //global dose issues
     bool showIsoLine = false;
     m_selectedNode->GetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(),showIsoLine);
     m_Controls.checkGlobalVisIsoLine->setChecked(showIsoLine);
 
     bool showColorWash = false;
     m_selectedNode->GetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(),showColorWash);
     m_Controls.checkGlobalVisColorWash->setChecked(showColorWash);
 
     float referenceDose = 0.0;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),referenceDose);
     m_Controls.spinReferenceDose->setValue(referenceDose);
 
     mitk::IsoDoseLevelSetProperty::Pointer propIsoSet =
       dynamic_cast<mitk::IsoDoseLevelSetProperty* >(m_selectedNode->GetProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str()));
 
     if (propIsoSet)
     {
       this->m_selectedNodeIsoSet = propIsoSet->GetValue();
       this->m_LevelSetModel->setIsoDoseLevelSet(m_selectedNodeIsoSet);
     }
   }
 }
 
 void RTDoseVisualizer::UpdateByPreferences()
 {
   m_Presets = mitk::rt::LoadPresetsMap();
   m_internalUpdate = true;
   m_Controls.comboPresets->clear();
   this->m_selectedPresetName = mitk::rt::GetSelectedPresetName();
 
   int index = 0;
   int selectedIndex = -1;
   for (mitk::rt::PresetMapType::const_iterator pos = m_Presets.begin(); pos != m_Presets.end(); ++pos, ++index)
   {
     m_Controls.comboPresets->addItem(QString(pos->first.c_str()));
     if (this->m_selectedPresetName == pos->first)
     {
       selectedIndex = index;
     }
   }
 
   if (selectedIndex == -1)
   {
     selectedIndex = 0;
     MITK_WARN << "Error. Cannot iso dose level preset specified in preferences does not exist. Preset name: "<<this->m_selectedPresetName;
     this->m_selectedPresetName = m_Presets.begin()->first;
     mitk::rt::SetSelectedPresetName(this->m_selectedPresetName);
     MITK_INFO << "Changed selected iso dose level preset to first existing preset. New preset name: "<<this->m_selectedPresetName;
   }
 
   m_Controls.comboPresets->setCurrentIndex(selectedIndex);
 
   this->m_selectedNodeIsoSet = this->m_Presets[this->m_selectedPresetName];
   this->m_LevelSetModel->setIsoDoseLevelSet(m_selectedNodeIsoSet);
 
   mitk::DoseValueAbs referenceDose = 0.0;
   bool globalSync = mitk::rt::GetReferenceDoseValue(referenceDose);
   if (globalSync || this->m_selectedNode.IsNull())
   {
     m_Controls.spinReferenceDose->setValue(referenceDose);
   }
 
   bool displayAbsoluteDose = mitk::rt::GetDoseDisplayAbsolute();
   m_Controls.radioAbsDose->setChecked(displayAbsoluteDose);
   m_Controls.radioRelDose->setChecked(!displayAbsoluteDose);
   this->m_LevelSetModel->setShowAbsoluteDose(displayAbsoluteDose);
   m_internalUpdate = false;
 }
 
 void RTDoseVisualizer::OnCurrentPresetChanged(const QString& presetName)
 {
   if (!  m_internalUpdate)
   {
     mitk::rt::SetSelectedPresetName(presetName.toStdString());
     this->UpdateByPreferences();
     this->ActualizeIsoLevelsForAllDoseDataNodes();
     this->UpdateBySelectedNode();
   }
 }
 
 void RTDoseVisualizer::ActualizeIsoLevelsForAllDoseDataNodes()
 {
   std::string presetName = mitk::rt::GetSelectedPresetName();
 
   mitk::rt::PresetMapType presetMap = mitk::rt::LoadPresetsMap();
 
   mitk::NodePredicateProperty::Pointer isDoseNode = mitk::NodePredicateProperty::New(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetSubset(isDoseNode);
 
   mitk::IsoDoseLevelSet* selectedPreset = presetMap[presetName];
 
   if (!selectedPreset)
   {
     mitkThrow() << "Error. Cannot actualize iso dose level preset. Selected preset idoes not exist. Preset name: "<<presetName;
   }
 
   for(mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end(); ++pos)
   {
     mitk::IsoDoseLevelSet::Pointer clonedPreset = selectedPreset->Clone();
     mitk::IsoDoseLevelSetProperty::Pointer propIsoSet = mitk::IsoDoseLevelSetProperty::New(clonedPreset);
     (*pos)->SetProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),propIsoSet);
   }
 }
 
 void RTDoseVisualizer::ActualizeReferenceDoseForAllDoseDataNodes()
 {
   /** @TODO Klären ob diese präsentations info genauso wie*/
   mitk::DoseValueAbs value = 0;
   bool sync = mitk::rt::GetReferenceDoseValue(value);
 
   if (sync)
   {
     mitk::NodePredicateProperty::Pointer isDoseNode = mitk::NodePredicateProperty::New(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
 
     mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetSubset(isDoseNode);
 
     for(mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end(); ++pos)
     {
       (*pos)->SetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
     }
   }
 }
 
 void RTDoseVisualizer::ActualizeDisplayStyleForAllDoseDataNodes()
 {
   /** @TODO Klären ob diese präsentations info global oder auch per node gespeichert wird*/
 }
 
 void RTDoseVisualizer::OnHandleCTKEventReferenceDoseChanged(const ctkEvent& event)
 {
   mitk::DoseValueAbs referenceDose = 0.0;
   bool globalSync = mitk::rt::GetReferenceDoseValue(referenceDose);
 
   this->m_Controls.spinReferenceDose->setValue(referenceDose);
 }
 
 void RTDoseVisualizer::OnHandleCTKEventPresetsChanged(const ctkEvent& event)
 {
   std::string currentPresetName  = mitk::rt::GetSelectedPresetName();
 
   this->OnCurrentPresetChanged(QString::fromStdString(currentPresetName));
 }