diff --git a/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.cpp b/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.cpp
index 555ada0468..8e7081a0f4 100644
--- a/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.cpp
@@ -1,181 +1,181 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #include "mitkContourVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkContour.h"
 
 #include <vtkActor.h>
 #include <vtkAppendPolyData.h>
 #include <vtkAssembly.h>
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #include <vtkCellArray.h>
 #pragma GCC diagnostic warning "-Wstrict-aliasing"
 #include <vtkFollower.h>
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolygon.h>
 #include <vtkProp3DCollection.h>
 #include <vtkProperty.h>
 #include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 #include <vtkTubeFilter.h>
 
 mitk::ContourVtkMapper3D::ContourVtkMapper3D()
 {
   m_VtkPolyDataMapper = vtkPolyDataMapper::New();
   m_VtkPointList = vtkAppendPolyData::New();
   m_Actor = vtkActor::New();
   m_Actor->SetMapper(m_VtkPolyDataMapper);
 
   m_TubeFilter = vtkTubeFilter::New();
 }
 
 mitk::ContourVtkMapper3D::~ContourVtkMapper3D()
 {
   if(m_VtkPolyDataMapper)
     m_VtkPolyDataMapper->Delete();
 
   if(m_TubeFilter)
     m_TubeFilter->Delete();
 
   if(m_VtkPointList)
     m_VtkPointList->Delete();
 
   if(m_Contour)
     m_Contour->Delete();
   
   if(m_Actor)
     m_Actor->Delete();
 }
 
 vtkProp* mitk::ContourVtkMapper3D::GetVtkProp(mitk::BaseRenderer*  /*renderer*/)
 {
   return m_Actor;
 }
 
-void mitk::ContourVtkMapper3D::GenerateData(mitk::BaseRenderer* renderer)
+void mitk::ContourVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   if ( IsVisible(renderer)==false )
   {
     m_Actor->VisibilityOff();
     return;
   }
   m_Actor->VisibilityOn();
 
   m_Contour = vtkPolyData::New();
 
   mitk::Contour::Pointer input  = const_cast<mitk::Contour*>(this->GetInput());
   bool makeContour = true;
 
   if ( makeContour )
   {
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
 
     int numPts=input->GetNumberOfPoints();
     if ( numPts > 200000 )
       numPts = 200000;
     mitk::Contour::PathPointer path = input->GetContourPath();
     mitk::Contour::PathType::InputType cstart = path->StartOfInput();
     mitk::Contour::PathType::InputType cend   = path->EndOfInput();
     mitk::Contour::PathType::InputType cstep  = (cend-cstart+1)/numPts;
     mitk::Contour::PathType::InputType ccur;
 
     vtkIdType ptIndex = 0;
     vtkIdType lastPointIndex = 0;
 
     mitk::Contour::PointsContainerPointer contourPoints = input->GetPoints();
     mitk::Contour::PointsContainerIterator pointsIt = contourPoints->Begin();
 
     vtkFloatingPointType vtkpoint[3];
 
     int i;
     float pointSize = 2;
     this->GetDataNode()->GetFloatProperty("spheres size", pointSize);
 
     bool showPoints = true;
     this->GetDataNode()->GetBoolProperty("show points", showPoints);
     if ( showPoints )
     {
       m_VtkPointList = vtkAppendPolyData::New();
     }
     for ( i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep )
     {
       itk2vtk(path->Evaluate(ccur), vtkpoint);
       points->InsertPoint(ptIndex, vtkpoint);
       if ( ptIndex > 0 )
       {
         int cell[2] = {ptIndex-1,ptIndex};
         lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
       }
       lastPointIndex = ptIndex;
       ++ptIndex;
 
       if ( showPoints )
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
 
         sphere->SetRadius(pointSize);
         sphere->SetCenter(vtkpoint);
 
         m_VtkPointList->AddInput(sphere->GetOutput());
         sphere->Update();
       }
     }
 
     if ( input->GetClosed() )
     {
       int cell[2] = {lastPointIndex,0};
       lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
     }
 
     m_Contour->SetPoints(points);
     m_Contour->SetLines(lines);
     m_Contour->Update();
 
     m_TubeFilter->SetInput(m_Contour);
     m_TubeFilter->SetRadius(pointSize / 2.0f);
     m_TubeFilter->SetNumberOfSides(8);
     m_TubeFilter->Update();
 
     if ( showPoints )
     {
       m_VtkPointList->AddInput(m_TubeFilter->GetOutput());
       m_VtkPolyDataMapper->SetInput(m_VtkPointList->GetOutput());
     }
     else
     {
       m_VtkPolyDataMapper->SetInput(m_TubeFilter->GetOutput());
     }
     vtkFloatingPointType rgba[4]={0.0f,1.0f,0.0f,0.6f};
     m_Actor->GetProperty()->SetColor(rgba);
     m_Actor->SetMapper(m_VtkPolyDataMapper);
   }
   
   SetVtkMapperImmediateModeRendering(m_VtkPolyDataMapper);
 }
 
 const mitk::Contour* mitk::ContourVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::Contour* > ( GetData() );
 }
diff --git a/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.h b/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.h
index e439511b88..cef2d7200e 100644
--- a/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.h
+++ b/Modules/MitkExt/Rendering/mitkContourVtkMapper3D.h
@@ -1,69 +1,69 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef MITK_CONTOUR_VTK_MAPPER_3D_H
 #define MITK_CONTOUR_VTK_MAPPER_3D_H
 
 #include "MitkExtExports.h"
 #include "mitkVtkMapper3D.h"
 
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 class vtkPolyDataMapper;
 class vtkAppendPolyData;
 class vtkActor;
 class vtkTubeFilter;
 
 namespace mitk {
 
 class BaseRenderer;
 class Contour;
 
 /** 
  @brief Vtk-based mapper for mitk::Contour
  @ingroup Mapper
  */
 class MitkExt_EXPORT ContourVtkMapper3D : public VtkMapper3D
 {
 public:
   mitkClassMacro(ContourVtkMapper3D, VtkMapper3D);
 
   itkNewMacro(Self);
 
   virtual const mitk::Contour* GetInput();
 
   virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
 
 protected:
   ContourVtkMapper3D();
   virtual ~ContourVtkMapper3D();
 
-  virtual void GenerateData(mitk::BaseRenderer* renderer);
+  virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
 
   vtkSmartPointer<vtkPolyDataMapper> m_VtkPolyDataMapper;
   vtkSmartPointer<vtkTubeFilter>     m_TubeFilter;
 
   vtkSmartPointer<vtkAppendPolyData> m_VtkPointList;
   vtkSmartPointer<vtkPolyData> m_Contour;
   vtkSmartPointer<vtkActor> m_Actor;
 };
 
 } // namespace mitk
 
 #endif // MITK_CONTOUR_VTK_MAPPER_3D_H
 
diff --git a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp
index cd94557cae..3d51ec5566 100644
--- a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp
@@ -1,711 +1,711 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-06-18 15:59:04 +0200 (Thu, 18 Jun 2009) $
 Version:   $Revision: 17786 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #define GPU_INFO MITK_INFO("mapper.vr")
 #define GPU_WARN MITK_WARN("mapper.vr")
 #define GPU_ERROR MITK_ERROR("mapper.vr")
 
 #include "mitkGPUVolumeMapper3D.h"
 
 #include "mitkDataNode.h"
 
 #include "mitkProperties.h"
 #include "mitkLevelWindow.h"
 #include "mitkColorProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkTransferFunctionInitializer.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include <vtkActor.h>
 #include <vtkProperty.h>
 
 #include <vtkVolumeTextureMapper2D.h>
 #include <vtkVolume.h>
 #include <vtkVolumeProperty.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkPiecewiseFunction.h>
 #include <vtkVolumeRayCastCompositeFunction.h>
 #include <vtkVolumeRayCastMIPFunction.h>
 #include <vtkFiniteDifferenceGradientEstimator.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkImageWriter.h>
 #include <vtkImageData.h>
 #include <vtkLODProp3D.h>
 #include <vtkImageResample.h>
 #include <vtkPlane.h>
 #include <vtkImplicitPlaneWidget.h>
 #include <vtkAssembly.h>
 
 #include <vtkCubeSource.h>
 #include <vtkPolyDataMapper.h>
 
 #include <itkMultiThreader.h>
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
 
 #include "vtkMitkGPUVolumeRayCastMapper.h"
 
 #endif
 
 #include "vtkMitkOpenGLGPUVolumeRayCastMapper.h"
 #include "vtkMitkOpenGLVolumeTextureMapper3D.h"
 
 
 const mitk::Image* mitk::GPUVolumeMapper3D::GetInput()
 {
   return static_cast<const mitk::Image*> ( GetData() );
 }
 
 void mitk::GPUVolumeMapper3D::MitkRenderVolumetricGeometry(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   VtkMapper3D::MitkRenderVolumetricGeometry(renderer);
 
   if(ls->m_gpuInitialized)
     ls->m_MapperGPU->UpdateMTime();
 }
 
 bool mitk::GPUVolumeMapper3D::InitGPU(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if(ls->m_gpuInitialized)
     return ls->m_gpuSupported;
   
   GPU_INFO << "initializing gpu-slicing-vr (vtkMitkOpenGLVolumeTextureMapper3D)";
   
   ls->m_MapperGPU = vtkMitkOpenGLVolumeTextureMapper3D::New();
   ls->m_MapperGPU->SetUseCompressedTexture(false);
   ls->m_MapperGPU->SetSampleDistance(1.0); 
    
   ls->m_VolumePropertyGPU = vtkVolumeProperty::New();
   ls->m_VolumePropertyGPU->ShadeOn();
   ls->m_VolumePropertyGPU->SetAmbient (0.25f); //0.05f
   ls->m_VolumePropertyGPU->SetDiffuse (0.50f); //0.45f
   ls->m_VolumePropertyGPU->SetSpecular(0.40f); //0.50f
   ls->m_VolumePropertyGPU->SetSpecularPower(16.0f);
   ls->m_VolumePropertyGPU->SetInterpolationTypeToLinear();
 
   ls->m_VolumeGPU = vtkVolume::New();
   ls->m_VolumeGPU->SetMapper( ls->m_MapperGPU );
   ls->m_VolumeGPU->SetProperty( ls->m_VolumePropertyGPU );
   ls->m_VolumeGPU->VisibilityOn();
 
   ls->m_MapperGPU->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
 
   ls->m_gpuSupported = ls->m_MapperGPU->IsRenderSupported(renderer->GetVtkRenderer(),ls->m_VolumePropertyGPU);
     
   ls->m_gpuInitialized = true;
   
   return ls->m_gpuSupported;
 }
 
 void mitk::GPUVolumeMapper3D::InitCPU(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if(ls->m_cpuInitialized)
     return;
 
   int numThreads = itk::MultiThreader::GetGlobalDefaultNumberOfThreads();
 
   GPU_INFO << "initializing cpu-raycast-vr (vtkFixedPointVolumeRayCastMapper) (" << numThreads << " threads)";
 
   ls->m_MapperCPU = vtkFixedPointVolumeRayCastMapper::New();
   ls->m_MapperCPU->SetSampleDistance(1.0); 
 //  ls->m_MapperCPU->LockSampleDistanceToInputSpacingOn(); 
   ls->m_MapperCPU->SetImageSampleDistance(1.0); 
   ls->m_MapperCPU->IntermixIntersectingGeometryOn();
   ls->m_MapperCPU->SetAutoAdjustSampleDistances(0);
 
   ls->m_MapperCPU->SetNumberOfThreads( numThreads );
   
   ls->m_VolumePropertyCPU = vtkVolumeProperty::New();
   ls->m_VolumePropertyCPU->ShadeOn();
   ls->m_VolumePropertyCPU->SetAmbient (0.10f); //0.05f
   ls->m_VolumePropertyCPU->SetDiffuse (0.50f); //0.45f
   ls->m_VolumePropertyCPU->SetSpecular(0.40f); //0.50f
   ls->m_VolumePropertyCPU->SetSpecularPower(16.0f);
   ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear();
 
   ls->m_VolumeCPU = vtkVolume::New();
   ls->m_VolumeCPU->SetMapper( ls->m_MapperCPU );
   ls->m_VolumeCPU->SetProperty( ls->m_VolumePropertyCPU );
   ls->m_VolumeCPU->VisibilityOn();
                     
   ls->m_MapperCPU->SetInput( m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
 
   ls->m_cpuInitialized=true;
 }
 
 void mitk::GPUVolumeMapper3D::DeinitGPU(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if(ls->m_gpuInitialized)
   {
     GPU_INFO << "deinitializing gpu-slicing-vr";
 
     ls->m_VolumeGPU->Delete();
     ls->m_MapperGPU->Delete();
     ls->m_VolumePropertyGPU->Delete();
     ls->m_gpuInitialized=false;
   }
 }
 
 void mitk::GPUVolumeMapper3D::DeinitCPU(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if(!ls->m_cpuInitialized)
     return;
 
   GPU_INFO << "deinitializing cpu-raycast-vr";
 
   ls->m_VolumeCPU->Delete();
   ls->m_MapperCPU->Delete();
   ls->m_VolumePropertyCPU->Delete();
   ls->m_cpuInitialized=false;
 }
 
 
 mitk::GPUVolumeMapper3D::GPUVolumeMapper3D()
 {
   m_VolumeNULL=0;
   m_commonInitialized=false;
 }
 
 
 mitk::GPUVolumeMapper3D::~GPUVolumeMapper3D()
 {
   DeinitCommon();
   if(m_VolumeNULL)
     m_VolumeNULL->Delete();
 }
 
 void mitk::GPUVolumeMapper3D::InitCommon()
 {
   if(m_commonInitialized)
     return;
 
   m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
   m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
 
   CreateDefaultTransferFunctions();
 
   m_commonInitialized=true;
 }
 
 void mitk::GPUVolumeMapper3D::DeinitCommon()
 {
   if(!m_commonInitialized)
     return;
 
   m_UnitSpacingImageFilter->Delete();
   
   m_DefaultColorTransferFunction->Delete();
   m_DefaultOpacityTransferFunction->Delete();
   m_DefaultGradientTransferFunction->Delete();
   m_BinaryColorTransferFunction->Delete();
   m_BinaryOpacityTransferFunction->Delete();
   m_BinaryGradientTransferFunction->Delete();
   
   m_commonInitialized=false;
 }
   
 bool mitk::GPUVolumeMapper3D::IsRenderable(mitk::BaseRenderer* renderer)
 {
   if(!IsVisible(renderer))
     return false;
 
   if(!GetDataNode())
     return false;
 
   bool value = false;
 
   if(!GetDataNode()->GetBoolProperty("volumerendering",value,renderer))
     return false;
     
   if(!value)
     return false;
   
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
   
   if ( !input || !input->IsInitialized() )
     return false;
 
   vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
   
   if(inputData==NULL)
     return false;
 
   return true;
 }
 
 void mitk::GPUVolumeMapper3D::InitVtkMapper(mitk::BaseRenderer* renderer)
 {
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
   if(IsRAYEnabled(renderer))
   {
     DeinitCPU(renderer);
     DeinitGPU(renderer);
     if(!InitRAY(renderer))
     {
       GPU_WARN << "hardware renderer can't initialize ... falling back to software renderer";
       goto fallback;
     }
   }
   else 
 #endif  
   if(IsGPUEnabled(renderer))
   {
     DeinitCPU(renderer);
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
     DeinitRAY(renderer);
 #endif
     if(!InitGPU(renderer))
     {
       GPU_WARN << "hardware renderer can't initialize ... falling back to software renderer";
       goto fallback;
     }
   }
   else
   {
     fallback:
     DeinitGPU(renderer);
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
     DeinitRAY(renderer);
 #endif
     InitCPU(renderer);
   }  
 }
 
 vtkProp *mitk::GPUVolumeMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   if(!IsRenderable(renderer))
   {
     if(!m_VolumeNULL)
     {
       m_VolumeNULL = vtkVolume::New();
       m_VolumeNULL->VisibilityOff();
     }
     return m_VolumeNULL;
   }
   
   InitCommon();
   InitVtkMapper( renderer );
   
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
   if(ls->m_rayInitialized)
     return ls->m_VolumeRAY;
 #endif  
   
   if(ls->m_gpuInitialized)
     return ls->m_VolumeGPU;
 
   return ls->m_VolumeCPU;
 }
 
 
-void mitk::GPUVolumeMapper3D::GenerateData( mitk::BaseRenderer *renderer )
+void mitk::GPUVolumeMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   if(!IsRenderable(renderer))
     return;
 
   InitCommon();
   InitVtkMapper( renderer );
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
   vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
   m_UnitSpacingImageFilter->SetInput( inputData );
 
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
   if(ls->m_rayInitialized)
   {
     GenerateDataRAY(renderer);
   }
   else 
 #endif
   
   if(ls->m_gpuInitialized)
   {
     GenerateDataGPU(renderer);
   }
   else
   {
     GenerateDataCPU(renderer);
   }
 
   // UpdateTransferFunctions  
   UpdateTransferFunctions( renderer );
 }
 
 void mitk::GPUVolumeMapper3D::GenerateDataGPU( mitk::BaseRenderer *renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   bool useCompression = false;
   GetDataNode()->GetBoolProperty("volumerendering.gpu.usetexturecompression",useCompression,renderer);
   ls->m_MapperGPU->SetUseCompressedTexture(useCompression);
 
   if( IsLODEnabled(renderer) && mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 )
     ls->m_MapperGPU->SetSampleDistance(2.0); 
   else
     ls->m_MapperGPU->SetSampleDistance(1.0); 
   
   // Updating shadings
   {
     float value=0;
     if(GetDataNode()->GetFloatProperty("volumerendering.gpu.ambient",value,renderer)) 
       ls->m_VolumePropertyGPU->SetAmbient(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.gpu.diffuse",value,renderer)) 
       ls->m_VolumePropertyGPU->SetDiffuse(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular",value,renderer)) 
       ls->m_VolumePropertyGPU->SetSpecular(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular.power",value,renderer)) 
       ls->m_VolumePropertyGPU->SetSpecularPower(value);
   }
 }
 
 void mitk::GPUVolumeMapper3D::GenerateDataCPU( mitk::BaseRenderer *renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   int nextLod = mitk::RenderingManager::GetInstance()->GetNextLOD( renderer );
 
   if( IsLODEnabled(renderer) && nextLod == 0 )
   {
     ls->m_MapperCPU->SetImageSampleDistance(3.5); 
     ls->m_MapperCPU->SetSampleDistance(1.25); 
     ls->m_VolumePropertyCPU->SetInterpolationTypeToNearest();
   }
   else
   {
     ls->m_MapperCPU->SetImageSampleDistance(1.0); 
     ls->m_MapperCPU->SetSampleDistance(1.0); 
     ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear();
   }
 
   // Check raycasting mode
   if(IsMIPEnabled(renderer))
     ls->m_MapperCPU->SetBlendModeToMaximumIntensity();
   else
     ls->m_MapperCPU->SetBlendModeToComposite();
 
   // Updating shadings
   {
     float value=0;
     if(GetDataNode()->GetFloatProperty("volumerendering.cpu.ambient",value,renderer)) 
       ls->m_VolumePropertyCPU->SetAmbient(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.cpu.diffuse",value,renderer)) 
       ls->m_VolumePropertyCPU->SetDiffuse(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular",value,renderer)) 
       ls->m_VolumePropertyCPU->SetSpecular(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular.power",value,renderer)) 
       ls->m_VolumePropertyCPU->SetSpecularPower(value);
   }
 }
 
 void mitk::GPUVolumeMapper3D::CreateDefaultTransferFunctions()
 {
   m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New();
   m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
   m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 );
   m_DefaultOpacityTransferFunction->ClampingOn();
 
   m_DefaultGradientTransferFunction = vtkPiecewiseFunction::New();
   m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 );
   m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 );
   m_DefaultGradientTransferFunction->ClampingOn();
 
   m_DefaultColorTransferFunction = vtkColorTransferFunction::New();
   m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
   m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 );
   m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 );
   m_DefaultColorTransferFunction->ClampingOn();
 
   m_BinaryOpacityTransferFunction = vtkPiecewiseFunction::New();
   m_BinaryOpacityTransferFunction->AddPoint( 0, 0.0 );
   m_BinaryOpacityTransferFunction->AddPoint( 1, 1.0 );
 
   m_BinaryGradientTransferFunction = vtkPiecewiseFunction::New();
   m_BinaryGradientTransferFunction->AddPoint( 0.0, 1.0 );
 
   m_BinaryColorTransferFunction = vtkColorTransferFunction::New();
 }
 
 void mitk::GPUVolumeMapper3D::UpdateTransferFunctions( mitk::BaseRenderer * renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   vtkPiecewiseFunction *opacityTransferFunction = m_DefaultOpacityTransferFunction;
   vtkPiecewiseFunction *gradientTransferFunction = m_DefaultGradientTransferFunction;
   vtkColorTransferFunction *colorTransferFunction = m_DefaultColorTransferFunction;
 
   bool isBinary = false;
 
   GetDataNode()->GetBoolProperty("binary", isBinary, renderer);
 
   if(isBinary)
   {
     opacityTransferFunction = m_BinaryOpacityTransferFunction;
     gradientTransferFunction = m_BinaryGradientTransferFunction;
     colorTransferFunction = m_BinaryColorTransferFunction;
 
     colorTransferFunction->RemoveAllPoints();
     float rgb[3];
     if( !GetDataNode()->GetColor( rgb,renderer ) )
        rgb[0]=rgb[1]=rgb[2]=1;
     colorTransferFunction->AddRGBPoint( 0,rgb[0],rgb[1],rgb[2] );
     colorTransferFunction->Modified();
   }
   else
   {
     mitk::TransferFunctionProperty *transferFunctionProp = 
       dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction",renderer));
 
     if( transferFunctionProp )   
     {
       opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
       gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
       colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
     }
   }
 
   if(ls->m_gpuInitialized)
   {
     ls->m_VolumePropertyGPU->SetColor( colorTransferFunction );
     ls->m_VolumePropertyGPU->SetScalarOpacity( opacityTransferFunction );
     ls->m_VolumePropertyGPU->SetGradientOpacity( gradientTransferFunction );
   }                                          
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
   
   if(ls->m_rayInitialized)
   {
     ls->m_VolumePropertyRAY->SetColor( colorTransferFunction );
     ls->m_VolumePropertyRAY->SetScalarOpacity( opacityTransferFunction );
     ls->m_VolumePropertyRAY->SetGradientOpacity( gradientTransferFunction );
   }
 
 #endif
   
   if(ls->m_cpuInitialized)
   {
     ls->m_VolumePropertyCPU->SetColor( colorTransferFunction );
     ls->m_VolumePropertyCPU->SetScalarOpacity( opacityTransferFunction );
     ls->m_VolumePropertyCPU->SetGradientOpacity( gradientTransferFunction );
   }                                              
 }
 
 
 void mitk::GPUVolumeMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* /*renderer*/)
 {
   //GPU_INFO << "ApplyProperties";
 }
 
 void mitk::GPUVolumeMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   //GPU_INFO << "SetDefaultProperties";
 
   node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "volumerendering.usemip", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "volumerendering.uselod", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   node->AddProperty( "volumerendering.cpu.ambient",  mitk::FloatProperty::New( 0.10f ), renderer, overwrite );
   node->AddProperty( "volumerendering.cpu.diffuse",  mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
   node->AddProperty( "volumerendering.cpu.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
   node->AddProperty( "volumerendering.cpu.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
   bool usegpu = true;
 #ifdef __APPLE__
   usegpu = false;
   node->AddProperty( "volumerendering.uselod", mitk::BoolProperty::New( true ), renderer, overwrite );
 #endif
   node->AddProperty( "volumerendering.usegpu", mitk::BoolProperty::New( usegpu ), renderer, overwrite );
   
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
   
   node->AddProperty( "volumerendering.useray", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   node->AddProperty( "volumerendering.ray.ambient",               mitk::FloatProperty::New( 0.25f ), renderer, overwrite );
   node->AddProperty( "volumerendering.ray.diffuse",               mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
   node->AddProperty( "volumerendering.ray.specular",              mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
   node->AddProperty( "volumerendering.ray.specular.power",        mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
 
 #endif
   node->AddProperty( "volumerendering.gpu.ambient",               mitk::FloatProperty::New( 0.25f ), renderer, overwrite );
   node->AddProperty( "volumerendering.gpu.diffuse",               mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
   node->AddProperty( "volumerendering.gpu.specular",              mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
   node->AddProperty( "volumerendering.gpu.specular.power",        mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
   node->AddProperty( "volumerendering.gpu.usetexturecompression", mitk::BoolProperty ::New( false ), renderer, overwrite );
   node->AddProperty( "volumerendering.gpu.reducesliceartifacts" , mitk::BoolProperty ::New( false ), renderer, overwrite );
 
   node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
  
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if(image.IsNotNull() && image->IsInitialized())
   {
     if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
     {
       mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
       mitk::LevelWindow levelwindow;
       levelwindow.SetAuto( image );
       levWinProp->SetLevelWindow( levelwindow );
       node->SetProperty( "levelwindow", levWinProp, renderer );
     }
     
     if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL))
     {
       // add a default transfer function
       mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
       mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
       tfInit->SetTransferFunctionMode(0);
       node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
     }
   }
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 bool mitk::GPUVolumeMapper3D::IsLODEnabled( mitk::BaseRenderer * renderer ) const
 {
   bool value = false;
   return GetDataNode()->GetBoolProperty("volumerendering.uselod",value,renderer) && value;
 }
 
 bool mitk::GPUVolumeMapper3D::IsMIPEnabled( mitk::BaseRenderer * renderer )
 {
   bool value = false;
   return GetDataNode()->GetBoolProperty("volumerendering.usemip",value,renderer) && value;
 }
 
 bool mitk::GPUVolumeMapper3D::IsGPUEnabled( mitk::BaseRenderer * renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool value = false;
   return ls->m_gpuSupported && GetDataNode()->GetBoolProperty("volumerendering.usegpu",value,renderer) && value;
 }
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
 
 bool mitk::GPUVolumeMapper3D::InitRAY(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if(ls->m_rayInitialized)
     return ls->m_raySupported;
   
   GPU_INFO << "initializing gpu-raycast-vr (vtkMitkOpenGLGPUVolumeRayCastMapper)";
   
   ls->m_MapperRAY = vtkMitkOpenGLGPUVolumeRayCastMapper::New();
   ls->m_MapperRAY->SetAutoAdjustSampleDistances(0);
   ls->m_MapperRAY->SetSampleDistance(1.0); 
    
   ls->m_VolumePropertyRAY = vtkVolumeProperty::New();
   ls->m_VolumePropertyRAY->ShadeOn();
   ls->m_VolumePropertyRAY->SetAmbient (0.25f); //0.05f
   ls->m_VolumePropertyRAY->SetDiffuse (0.50f); //0.45f
   ls->m_VolumePropertyRAY->SetSpecular(0.40f); //0.50f
   ls->m_VolumePropertyRAY->SetSpecularPower(16.0f);
   ls->m_VolumePropertyRAY->SetInterpolationTypeToLinear();
 
   ls->m_VolumeRAY = vtkVolume::New();
   ls->m_VolumeRAY->SetMapper( ls->m_MapperRAY );
   ls->m_VolumeRAY->SetProperty( ls->m_VolumePropertyRAY );
   ls->m_VolumeRAY->VisibilityOn();
   
   ls->m_MapperRAY->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
 
   ls->m_raySupported = ls->m_MapperRAY->IsRenderSupported(renderer->GetRenderWindow(),ls->m_VolumePropertyRAY);
 
   ls->m_rayInitialized = true;
   
   return ls->m_raySupported;
 }
 
 void mitk::GPUVolumeMapper3D::DeinitRAY(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if(ls->m_rayInitialized)
   {
     GPU_INFO << "deinitializing gpu-raycast-vr";
 
     ls->m_VolumeRAY->Delete();
     ls->m_MapperRAY->Delete();
     ls->m_VolumePropertyRAY->Delete();
     ls->m_rayInitialized=false;
   }
 }
 
 void mitk::GPUVolumeMapper3D::GenerateDataRAY( mitk::BaseRenderer *renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if( IsLODEnabled(renderer) && mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 )
     ls->m_MapperRAY->SetImageSampleDistance(4.0); 
   else
     ls->m_MapperRAY->SetImageSampleDistance(1.0); 
   
   // Check raycasting mode
   if(IsMIPEnabled(renderer))
     ls->m_MapperRAY->SetBlendModeToMaximumIntensity();
   else
     ls->m_MapperRAY->SetBlendModeToComposite();
 
   // Updating shadings
   {
     float value=0;
     if(GetDataNode()->GetFloatProperty("volumerendering.ray.ambient",value,renderer)) 
       ls->m_VolumePropertyRAY->SetAmbient(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.ray.diffuse",value,renderer)) 
       ls->m_VolumePropertyRAY->SetDiffuse(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.ray.specular",value,renderer)) 
       ls->m_VolumePropertyRAY->SetSpecular(value);
     if(GetDataNode()->GetFloatProperty("volumerendering.ray.specular.power",value,renderer)) 
       ls->m_VolumePropertyRAY->SetSpecularPower(value);
   }
   
 }
 
 bool mitk::GPUVolumeMapper3D::IsRAYEnabled( mitk::BaseRenderer * renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool value = false;
   return ls->m_raySupported && GetDataNode()->GetBoolProperty("volumerendering.useray",value,renderer) && value;
 }
 
 #endif
diff --git a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h
index c10b614a42..3bc49e7137 100644
--- a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h
+++ b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h
@@ -1,204 +1,204 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-26 17:32:07 +0200 (Tue, 26 May 2009) $
 Version:   $Revision: 17418 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef MITKGPUVOLUMEMAPPER3D_H_HEADER_INCLUDED
 #define MITKGPUVOLUMEMAPPER3D_H_HEADER_INCLUDED
 
 #include "mitkCommon.h"
 #include "MitkExtExports.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkVtkMapper3D.h"
 #include "mitkImage.h"
 
 #include <vtkFixedPointVolumeRayCastMapper.h>
 #include "vtkMitkVolumeTextureMapper3D.h"
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
 
 #include "vtkMitkGPUVolumeRayCastMapper.h"
 
 #endif
 
 #include <vtkVolumeProperty.h>
 #include <vtkImageChangeInformation.h>
 
 namespace mitk {
 
   /************************************************************************/
   /* Properties that influence the mapper are:
   *
   * - \b "level window": for the level window of the volume data
   * - \b "LookupTable" : for the lookup table of the volume data
   * - \b "TransferFunction" (mitk::TransferFunctionProperty): for the used transfer function of the volume data
   ************************************************************************/
 
 //##Documentation
 //## @brief Vtk-based mapper for VolumeData
 //##
 //## @ingroup Mapper
 class MitkExt_EXPORT GPUVolumeMapper3D : public VtkMapper3D
 {
 public:
   mitkClassMacro(GPUVolumeMapper3D, VtkMapper3D);
 
   itkNewMacro(Self);
 
   virtual const mitk::Image* GetInput();
   
   virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer);
 
   virtual void ApplyProperties(vtkActor* actor, mitk::BaseRenderer* renderer);
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
   /** Returns true if this Mapper currently allows for Level-of-Detail rendering.
    * This reflects whether this Mapper currently invokes StartEvent, EndEvent, and
    * ProgressEvent on BaseRenderer. */
   virtual bool IsLODEnabled( BaseRenderer *renderer = NULL ) const;
   bool IsMIPEnabled( BaseRenderer *renderer = NULL );
   bool IsGPUEnabled( BaseRenderer *renderer = NULL );
   bool IsRAYEnabled( BaseRenderer *renderer = NULL );
   
   virtual void MitkRenderVolumetricGeometry(mitk::BaseRenderer* renderer);
 
 protected:
 
   GPUVolumeMapper3D();
   virtual ~GPUVolumeMapper3D();
 
   bool IsRenderable(mitk::BaseRenderer* renderer);
 
   void InitCommon();
   void DeinitCommon();
 
   void InitCPU(mitk::BaseRenderer* renderer);
   void DeinitCPU(mitk::BaseRenderer* renderer);
   void GenerateDataCPU(mitk::BaseRenderer* renderer);
 
   bool InitGPU(mitk::BaseRenderer* renderer);
   void DeinitGPU(mitk::BaseRenderer* renderer);
   void GenerateDataGPU(mitk::BaseRenderer* renderer);
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
 
   bool InitRAY(mitk::BaseRenderer* renderer);
   void DeinitRAY(mitk::BaseRenderer* renderer);
   void GenerateDataRAY(mitk::BaseRenderer* renderer);
 
 #endif
 
   void InitVtkMapper(mitk::BaseRenderer* renderer);
 
-  virtual void GenerateData(mitk::BaseRenderer* renderer);
+  virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
 
   void CreateDefaultTransferFunctions();
   void UpdateTransferFunctions( mitk::BaseRenderer *renderer );
 
   vtkVolume * m_VolumeNULL;
   
   bool m_commonInitialized;
   vtkImageChangeInformation* m_UnitSpacingImageFilter;
   vtkPiecewiseFunction *m_DefaultOpacityTransferFunction;
   vtkPiecewiseFunction *m_DefaultGradientTransferFunction;
   vtkColorTransferFunction *m_DefaultColorTransferFunction;
   vtkPiecewiseFunction *m_BinaryOpacityTransferFunction;
   vtkPiecewiseFunction *m_BinaryGradientTransferFunction;
   vtkColorTransferFunction *m_BinaryColorTransferFunction;
   
   class LocalStorage : public mitk::Mapper::BaseLocalStorage
   {
     public:
 
     bool m_cpuInitialized;
     vtkVolume *m_VolumeCPU;
     vtkFixedPointVolumeRayCastMapper* m_MapperCPU;
     vtkVolumeProperty* m_VolumePropertyCPU;
 
     bool m_gpuSupported;
     bool m_gpuInitialized;
     vtkVolume *m_VolumeGPU;
     vtkMitkVolumeTextureMapper3D* m_MapperGPU;
     vtkVolumeProperty* m_VolumePropertyGPU;
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
 
     bool m_raySupported;
     bool m_rayInitialized;
     vtkVolume *m_VolumeRAY;
     vtkMitkGPUVolumeRayCastMapper* m_MapperRAY;
     vtkVolumeProperty* m_VolumePropertyRAY;
 
 #endif
 
     LocalStorage()
     {
       m_cpuInitialized = false;
       
       m_gpuInitialized = false;
       m_gpuSupported = true;    // assume initially gpu slicing is supported
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
       m_rayInitialized = false;
       m_raySupported = true;    // assume initially gpu raycasting is supported
 #endif
     }
     
     ~LocalStorage()
     {
       if(m_cpuInitialized)
       {
         m_VolumeCPU->Delete();
         m_MapperCPU->Delete();
         m_VolumePropertyCPU->Delete();
         m_cpuInitialized=false;
       }
 
       if(m_gpuInitialized)
       {
         m_VolumeGPU->Delete();
         m_MapperGPU->Delete();
         m_VolumePropertyGPU->Delete();
         m_gpuInitialized=false;
       }
 
 // Only with VTK 5.6 or above
 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
 
       if(m_rayInitialized)
       {
         m_VolumeRAY->Delete();
         m_MapperRAY->Delete();
         m_VolumePropertyRAY->Delete();
         m_rayInitialized=false;
       }
 
 #endif
 
     }
   };  
     
   mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;  
 };
 
 } // namespace mitk
 
 #endif /* MITKVOLUMEDATAVTKMAPPER3D_H_HEADER_INCLUDED */