diff --git a/Core/Code/Algorithms/mitkClippedSurfaceBoundsCalculator.cpp b/Core/Code/Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
index ade2ae5f4b..aff97b6af2 100644
--- a/Core/Code/Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
+++ b/Core/Code/Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
@@ -1,354 +1,354 @@
 /*===================================================================
 
 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 "mitkClippedSurfaceBoundsCalculator.h"
 #include "mitkLine.h"
 
 #define ROUND_P(x) ((x)>=0?(int)((x)+0.5):(int)((x)-0.5))
 
 mitk::ClippedSurfaceBoundsCalculator::ClippedSurfaceBoundsCalculator(
     const mitk::PlaneGeometry* geometry,
     mitk::Image::Pointer image)
 : m_PlaneGeometry(NULL)
 , m_Geometry3D(NULL)
 , m_Image(NULL)
 {
   this->InitializeOutput();
 
   this->SetInput(geometry, image);
 }
 
 mitk::ClippedSurfaceBoundsCalculator::ClippedSurfaceBoundsCalculator(
     const mitk::BaseGeometry* geometry,
     mitk::Image::Pointer image)
 : m_PlaneGeometry(NULL)
 , m_Geometry3D(NULL)
 , m_Image(NULL)
 {
   this->InitializeOutput();
 
   this->SetInput(geometry, image);
 }
 
 mitk::ClippedSurfaceBoundsCalculator::ClippedSurfaceBoundsCalculator( const PointListType pointlist, mitk::Image::Pointer image )
 : m_PlaneGeometry(NULL)
 , m_Geometry3D(NULL)
 , m_Image(image)
 {
   this->InitializeOutput();
 
   m_ObjectPointsInWorldCoordinates = pointlist;
 }
 
 void mitk::ClippedSurfaceBoundsCalculator::InitializeOutput()
 {
   // initialize with meaningless slice indices
   m_MinMaxOutput.clear();
   for(int i = 0; i < 3; i++)
   {
     m_MinMaxOutput.push_back(
       OutputType( std::numeric_limits<int>::max() ,
       std::numeric_limits<int>::min() ));
   }
 }
 
 mitk::ClippedSurfaceBoundsCalculator::~ClippedSurfaceBoundsCalculator()
 {
 }
 
 void
 mitk::ClippedSurfaceBoundsCalculator::SetInput(
     const mitk::PlaneGeometry* geometry,
     mitk::Image* image)
 {
   if(geometry && image)
   {
     this->m_PlaneGeometry = geometry;
     this->m_Image = image;
     this->m_Geometry3D = NULL;        //Not possible to set both
     m_ObjectPointsInWorldCoordinates.clear();
   }
 }
 
 void
 mitk::ClippedSurfaceBoundsCalculator::SetInput(
     const mitk::BaseGeometry* geometry,
     mitk::Image* image)
 {
   if(geometry && image)
   {
     this->m_Geometry3D = geometry;
     this->m_Image = image;
     this->m_PlaneGeometry = NULL;     //Not possible to set both
     m_ObjectPointsInWorldCoordinates.clear();
   }
 }
 
 void mitk::ClippedSurfaceBoundsCalculator::SetInput( const std::vector<mitk::Point3D> pointlist, mitk::Image *image )
 {
   if ( !pointlist.empty() && image )
   {
     m_Geometry3D = NULL;
     m_PlaneGeometry = NULL;
     m_Image = image;
     m_ObjectPointsInWorldCoordinates = pointlist;
   }
 }
 
 mitk::ClippedSurfaceBoundsCalculator::OutputType
 mitk::ClippedSurfaceBoundsCalculator::GetMinMaxSpatialDirectionX()
 {
   return this->m_MinMaxOutput[0];
 }
 
 mitk::ClippedSurfaceBoundsCalculator::OutputType
 mitk::ClippedSurfaceBoundsCalculator::GetMinMaxSpatialDirectionY()
 {
   return this->m_MinMaxOutput[1];
 }
 
 mitk::ClippedSurfaceBoundsCalculator::OutputType
 mitk::ClippedSurfaceBoundsCalculator::GetMinMaxSpatialDirectionZ()
 {
   return this->m_MinMaxOutput[2];
 }
 
 void mitk::ClippedSurfaceBoundsCalculator::Update()
 {
   this->m_MinMaxOutput.clear();
   for(int i = 0; i < 3; i++)
   {
     this->m_MinMaxOutput.push_back(OutputType( std::numeric_limits<int>::max() , std::numeric_limits<int>::min() ));
   }
 
   if(m_PlaneGeometry.IsNotNull())
   {
     this->CalculateIntersectionPoints(m_PlaneGeometry);
   }
   else if(m_Geometry3D.IsNotNull())
   {
     // go through all slices of the image, ...
     const mitk::SlicedGeometry3D* slicedGeometry3D = dynamic_cast<const mitk::SlicedGeometry3D*>( m_Geometry3D.GetPointer() );
     int allSlices = slicedGeometry3D->GetSlices();
-    this->CalculateIntersectionPoints(dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry3D->GetGeometry2D(0)));
-    this->CalculateIntersectionPoints(dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry3D->GetGeometry2D(allSlices-1)));
+    this->CalculateIntersectionPoints(dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry3D->GetPlaneGeometry(0)));
+    this->CalculateIntersectionPoints(dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry3D->GetPlaneGeometry(allSlices-1)));
   }
   else if( !m_ObjectPointsInWorldCoordinates.empty() )
   {
     this->CalculateIntersectionPoints( m_ObjectPointsInWorldCoordinates );
   }
 }
 
 void mitk::ClippedSurfaceBoundsCalculator::CalculateIntersectionPoints(const mitk::PlaneGeometry* geometry)
 {
   // SEE HEADER DOCUMENTATION for explanation
 
   typedef std::vector< std::pair<mitk::Point3D, mitk::Point3D> > EdgesVector;
 
   Point3D origin;
   Vector3D xDirection, yDirection, zDirection;
   const Vector3D spacing = m_Image->GetGeometry()->GetSpacing();
 
   origin = m_Image->GetGeometry()->GetOrigin();           //Left, bottom, front
 
   //Get axis vector for the spatial directions
   xDirection = m_Image->GetGeometry()->GetAxisVector(1);
   yDirection = m_Image->GetGeometry()->GetAxisVector(0);
   zDirection = m_Image->GetGeometry()->GetAxisVector(2);
 
   /*
    *  For the calculation of the intersection points we need as corner points the center-based image coordinates.
    * With the method GetCornerPoint() of the class Geometry3D we only get the corner-based coordinates.
    * Therefore we need to calculate the center-based corner points here. For that we add/substract the corner-
    * based coordinates with the spacing of the geometry3D.
    */
   for( int i = 0; i < 3; i++ )
   {
     if(xDirection[i] < 0)
     {
       xDirection[i] += spacing[i];
     }
     else if( xDirection[i] > 0 )
     {
       xDirection[i] -= spacing[i];
     }
 
     if(yDirection[i] < 0)
     {
       yDirection[i] += spacing[i];
     }
     else if( yDirection[i] > 0 )
     {
       yDirection[i] -= spacing[i];
     }
 
     if(zDirection[i] < 0)
     {
       zDirection[i] += spacing[i];
     }
     else if( zDirection[i] > 0 )
     {
       zDirection[i] -= spacing[i];
     }
   }
 
   Point3D leftBottomFront, leftTopFront, leftBottomBack, leftTopBack;
   Point3D rightBottomFront, rightTopFront, rightBottomBack, rightTopBack;
 
   leftBottomFront = origin;
   leftTopFront = origin + yDirection;
   leftBottomBack = origin + zDirection;
   leftTopBack = origin + yDirection + zDirection;
   rightBottomFront = origin + xDirection;
   rightTopFront = origin + xDirection + yDirection;
   rightBottomBack = origin + xDirection + zDirection;
   rightTopBack = origin + xDirection + yDirection + zDirection;
 
   EdgesVector edgesOf3DBox;
 
   edgesOf3DBox.push_back(std::make_pair(leftBottomBack,     // x = left=xfront, y=bottom=yfront, z=front=zfront
                                         leftTopFront));     // left, top, front
 
   edgesOf3DBox.push_back(std::make_pair(leftBottomFront,    // left, bottom, front
                                         leftBottomBack));   // left, bottom, back
 
   edgesOf3DBox.push_back(std::make_pair(leftBottomFront,    // left, bottom, front
                                         rightBottomFront)); // right, bottom, front
 
   edgesOf3DBox.push_back(std::make_pair(leftTopFront,       // left, top, front
                                         rightTopFront));    // right, top, front
 
   edgesOf3DBox.push_back(std::make_pair(leftTopFront,       // left, top, front
                                         leftTopBack));      // left, top, back
 
   edgesOf3DBox.push_back(std::make_pair(rightTopFront,      // right, top, front
                                         rightTopBack));     // right, top, back
 
   edgesOf3DBox.push_back(std::make_pair(rightTopFront,      // right, top, front
                                         rightBottomFront)); // right, bottom, front
 
   edgesOf3DBox.push_back(std::make_pair(rightBottomFront,   // right, bottom, front
                                         rightBottomBack));  // right, bottom, back
 
   edgesOf3DBox.push_back(std::make_pair(rightBottomBack,    // right, bottom, back
                                         leftBottomBack));   // left, bottom, back
 
   edgesOf3DBox.push_back(std::make_pair(rightBottomBack,    // right, bottom, back
                                         rightTopBack));     // right, top, back
 
   edgesOf3DBox.push_back(std::make_pair(rightTopBack,       // right, top, back
                                         leftTopBack));      // left, top, back
 
   edgesOf3DBox.push_back(std::make_pair(leftTopBack,        // left, top, back
                                         leftBottomBack));   // left, bottom, back
 
 
 
   for (EdgesVector::iterator iterator = edgesOf3DBox.begin(); iterator != edgesOf3DBox.end();iterator++)
   {
     Point3D startPoint = (*iterator).first;   // start point of the line
     Point3D endPoint   = (*iterator).second;  // end point of the line
     Vector3D lineDirection = endPoint - startPoint;
 
     mitk::Line3D line(startPoint, lineDirection);
 
     Point3D intersectionWorldPoint;
     intersectionWorldPoint.Fill(std::numeric_limits<int>::min());
 
     // Get intersection point of line and plane geometry
     geometry->IntersectionPoint(line, intersectionWorldPoint);
 
     double t = -1.0;
 
     bool doesLineIntersectWithPlane(false);
 
     if(line.GetDirection().GetNorm() < mitk::eps && geometry->Distance(line.GetPoint1()) < mitk::sqrteps)
     {
       t = 1.0;
       doesLineIntersectWithPlane = true;
       intersectionWorldPoint = line.GetPoint1();
     }
     else
     {
       geometry->IntersectionPoint(line, intersectionWorldPoint);
       doesLineIntersectWithPlane = geometry->IntersectionPointParam(line, t);
     }
 
     mitk::Point3D intersectionIndexPoint;
     //Get index point
     m_Image->GetGeometry()->WorldToIndex(intersectionWorldPoint, intersectionIndexPoint);
 
     if ( doesLineIntersectWithPlane && -mitk::sqrteps <= t && t <= 1.0 + mitk::sqrteps )
     {
       for(int dim = 0; dim < 3; dim++)
       {
         // minimum
         //If new point value is lower than old
         if( this->m_MinMaxOutput[dim].first > ROUND_P(intersectionIndexPoint[dim]) )
         {
             this->m_MinMaxOutput[dim].first = ROUND_P(intersectionIndexPoint[dim]);     //set new value
         }
 
         // maximum
         //If new point value is higher than old
         if( this->m_MinMaxOutput[dim].second < ROUND_P(intersectionIndexPoint[dim]) )
         {
             this->m_MinMaxOutput[dim].second = ROUND_P(intersectionIndexPoint[dim]);     //set new value
         }
       }
 
       this->EnforceImageBounds();
     }
   }
 }
 
 void mitk::ClippedSurfaceBoundsCalculator::CalculateIntersectionPoints( PointListType pointList )
 {
   PointListType::iterator pointIterator;
 
   mitk::SlicedGeometry3D::Pointer imageGeometry = m_Image->GetSlicedGeometry();
 
 
   for ( pointIterator = pointList.begin(); pointIterator != pointList.end(); pointIterator++ )
   {
     mitk::Point3D pntInIndexCoordinates;
     imageGeometry->WorldToIndex( (*pointIterator), pntInIndexCoordinates );
 
     m_MinMaxOutput[0].first = pntInIndexCoordinates[0] < m_MinMaxOutput[0].first ? ROUND_P(pntInIndexCoordinates[0]) : m_MinMaxOutput[0].first;
     m_MinMaxOutput[0].second = pntInIndexCoordinates[0] > m_MinMaxOutput[0].second ? ROUND_P(pntInIndexCoordinates[0]) : m_MinMaxOutput[0].second;
 
     m_MinMaxOutput[1].first = pntInIndexCoordinates[1] < m_MinMaxOutput[1].first ? ROUND_P(pntInIndexCoordinates[1]) : m_MinMaxOutput[1].first;
     m_MinMaxOutput[1].second = pntInIndexCoordinates[1] > m_MinMaxOutput[1].second ? ROUND_P(pntInIndexCoordinates[1]) : m_MinMaxOutput[1].second;
 
     m_MinMaxOutput[2].first = pntInIndexCoordinates[2] < m_MinMaxOutput[2].first ? ROUND_P(pntInIndexCoordinates[2]) : m_MinMaxOutput[2].first;
     m_MinMaxOutput[2].second = pntInIndexCoordinates[2] > m_MinMaxOutput[2].second ? ROUND_P(pntInIndexCoordinates[2]) : m_MinMaxOutput[2].second;
   }
 
   this->EnforceImageBounds();
 
 }
 
 void mitk::ClippedSurfaceBoundsCalculator::EnforceImageBounds()
 {
   m_MinMaxOutput[0].first = std::max( m_MinMaxOutput[0].first, 0 );
   m_MinMaxOutput[1].first = std::max( m_MinMaxOutput[1].first, 0 );
   m_MinMaxOutput[2].first = std::max( m_MinMaxOutput[2].first, 0 );
 
   m_MinMaxOutput[0].second = std::min( m_MinMaxOutput[0].second, (int) m_Image->GetDimension(0)-1 );
   m_MinMaxOutput[1].second = std::min( m_MinMaxOutput[1].second, (int) m_Image->GetDimension(1)-1 );
   m_MinMaxOutput[2].second = std::min( m_MinMaxOutput[2].second, (int) m_Image->GetDimension(2)-1 );
 }
 
 
diff --git a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
index ca0f0c0689..7c49cd1940 100644
--- a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
+++ b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
@@ -1,486 +1,486 @@
 /*===================================================================
 
 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 "mitkExtractSliceFilter.h"
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 #include <vtkLinearTransform.h>
 #include <vtkImageChangeInformation.h>
 #include <mitkAbstractTransformGeometry.h>
 #include <vtkGeneralTransform.h>
 #include <mitkPlaneClipping.h>
 
 mitk::ExtractSliceFilter::ExtractSliceFilter(vtkImageReslice* reslicer ){
 
   if(reslicer == NULL){
     m_Reslicer = vtkSmartPointer<vtkImageReslice>::New();
   }
   else
   {
     m_Reslicer = reslicer;
   }
 
   m_TimeStep = 0;
   m_Reslicer->ReleaseDataFlagOn();
   m_InterpolationMode = ExtractSliceFilter::RESLICE_NEAREST;
   m_ResliceTransform = NULL;
   m_InPlaneResampleExtentByGeometry = false;
   m_OutPutSpacing = new mitk::ScalarType[2];
   m_OutputDimension = 2;
   m_ZSpacing = 1.0;
   m_ZMin = 0;
   m_ZMax = 0;
   m_VtkOutputRequested = false;
 
 }
 
 mitk::ExtractSliceFilter::~ExtractSliceFilter(){
   m_ResliceTransform = NULL;
   m_WorldGeometry = NULL;
   delete [] m_OutPutSpacing;
 }
 
 void mitk::ExtractSliceFilter::GenerateOutputInformation(){
   Superclass::GenerateOutputInformation();
   //TODO try figure out how to set the specs of the slice before it is actually extracted
   /*Image::Pointer output = this->GetOutput();
   Image::ConstPointer input = this->GetInput();
   if (input.IsNull()) return;
   unsigned int dimensions[2];
   dimensions[0] = m_WorldGeometry->GetExtent(0);
   dimensions[1] = m_WorldGeometry->GetExtent(1);
   output->Initialize(input->GetPixelType(), 2, dimensions, 1);*/
 }
 
 void mitk::ExtractSliceFilter::GenerateInputRequestedRegion(){
   //As we want all pixel information fo the image in our plane, the requested region
   //is set to the largest possible region in the image.
   //This is needed because an oblique plane has a larger extent then the image
   //and the in pipeline it is checked via PropagateResquestedRegion(). But the
   //extent of the slice is actually fitting because it is oblique within the image.
   ImageToImageFilter::InputImagePointer input =  const_cast< ImageToImageFilter::InputImageType* > ( this->GetInput() );
   input->SetRequestedRegionToLargestPossibleRegion();
 }
 
 
 mitk::ScalarType* mitk::ExtractSliceFilter::GetOutputSpacing(){
   return m_OutPutSpacing;
 }
 
 
 void mitk::ExtractSliceFilter::GenerateData(){
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
 
   if (!input)
   {
     MITK_ERROR << "mitk::ExtractSliceFilter: No input image available. Please set the input!" << std::endl;
     itkExceptionMacro("mitk::ExtractSliceFilter: No input image available. Please set the input!");
     return;
   }
 
   if(!m_WorldGeometry)
   {
     MITK_ERROR << "mitk::ExtractSliceFilter: No Geometry for reslicing available." << std::endl;
     itkExceptionMacro("mitk::ExtractSliceFilter: No Geometry for reslicing available.");
     return;
   }
 
 
   const TimeGeometry* inputTimeGeometry = this->GetInput()->GetTimeGeometry();
   if ( ( inputTimeGeometry == NULL )
     || ( inputTimeGeometry->CountTimeSteps() <= 0 ) )
   {
     itkWarningMacro(<<"Error reading input image TimeGeometry.");
     return;
   }
 
   // is it a valid timeStep?
   if ( inputTimeGeometry->IsValidTimeStep( m_TimeStep ) == false )
   {
     itkWarningMacro(<<"This is not a valid timestep: "<< m_TimeStep );
     return;
   }
 
   // check if there is something to display.
   if ( ! input->IsVolumeSet( m_TimeStep ) )
   {
     itkWarningMacro(<<"No volume data existent at given timestep "<< m_TimeStep );
     return;
   }
 
 
 
 
   /*================#BEGIN setup vtkImageRslice properties================*/
   Point3D origin;
   Vector3D right, bottom, normal;
   double widthInMM, heightInMM;
   Vector2D extent;
 
 
   const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(m_WorldGeometry);
 
 
   if ( planeGeometry != NULL )
   {
     //if the worldGeomatry is a PlaneGeometry everthing is straight forward
 
     origin = planeGeometry->GetOrigin();
     right  = planeGeometry->GetAxisVector( 0 );
     bottom = planeGeometry->GetAxisVector( 1 );
     normal = planeGeometry->GetNormal();
 
     if ( m_InPlaneResampleExtentByGeometry )
     {
       // Resampling grid corresponds to the current world geometry. This
       // means that the spacing of the output 2D image depends on the
       // currently selected world geometry, and *not* on the image itself.
       extent[0] = m_WorldGeometry->GetExtent( 0 );
       extent[1] = m_WorldGeometry->GetExtent( 1 );
     }
     else
     {
       // Resampling grid corresponds to the input geometry. This means that
       // the spacing of the output 2D image is directly derived from the
       // associated input image, regardless of the currently selected world
       // geometry.
       Vector3D rightInIndex, bottomInIndex;
       inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->WorldToIndex( right, rightInIndex );
       inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->WorldToIndex( bottom, bottomInIndex );
       extent[0] = rightInIndex.GetNorm();
       extent[1] = bottomInIndex.GetNorm();
     }
 
     // Get the extent of the current world geometry and calculate resampling
     // spacing therefrom.
     widthInMM = m_WorldGeometry->GetExtentInMM( 0 );
     heightInMM = m_WorldGeometry->GetExtentInMM( 1 );
 
 
     m_OutPutSpacing[0] = widthInMM / extent[0];
     m_OutPutSpacing[1] = heightInMM / extent[1];
 
 
     right.Normalize();
     bottom.Normalize();
     normal.Normalize();
 
 
     /*
     * Transform the origin to center based coordinates.
     * Note:
     * This is needed besause vtk's origin is center based too (!!!) ( see 'The VTK book' page 88 )
     * and the worldGeometry surrouding the image is no imageGeometry. So the worldGeometry
     * has its origin at the corner of the voxel and needs to be transformed.
     */
     origin += right * ( m_OutPutSpacing[0] * 0.5 );
     origin += bottom * ( m_OutPutSpacing[1] * 0.5 );
 
 
 
     //set the tranform for reslicing.
     // Use inverse transform of the input geometry for reslicing the 3D image.
     // This is needed if the image volume already transformed
     if(m_ResliceTransform.IsNotNull())
       m_Reslicer->SetResliceTransform(m_ResliceTransform->GetVtkTransform()->GetLinearInverse());
 
 
-    // Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D),
+    // Set background level to TRANSLUCENT (see PlaneGeometryDataVtkMapper3D),
     // else the background of the image turns out gray
     m_Reslicer->SetBackgroundLevel( -32768 );
 
   }
   else{
     //Code for curved planes, mostly taken 1:1 from imageVtkMapper2D and not tested yet.
     // Do we have an AbstractTransformGeometry?
     // This is the case for AbstractTransformGeometry's (e.g. a ThinPlateSplineCurvedGeometry )
     const mitk::AbstractTransformGeometry* abstractGeometry =
       dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry);
 
     if(abstractGeometry != NULL)
     {
       m_ResliceTransform = abstractGeometry;
 
       extent[0] = abstractGeometry->GetParametricExtent(0);
       extent[1] = abstractGeometry->GetParametricExtent(1);
 
       widthInMM = abstractGeometry->GetParametricExtentInMM(0);
       heightInMM = abstractGeometry->GetParametricExtentInMM(1);
 
       m_OutPutSpacing[0] = widthInMM / extent[0];
       m_OutPutSpacing[1] = heightInMM / extent[1];
 
       origin = abstractGeometry->GetPlane()->GetOrigin();
 
       right = abstractGeometry->GetPlane()->GetAxisVector(0);
       right.Normalize();
 
       bottom = abstractGeometry->GetPlane()->GetAxisVector(1);
       bottom.Normalize();
 
       normal = abstractGeometry->GetPlane()->GetNormal();
       normal.Normalize();
 
       // Use a combination of the InputGeometry *and* the possible non-rigid
       // AbstractTransformGeometry for reslicing the 3D Image
       vtkSmartPointer<vtkGeneralTransform> composedResliceTransform = vtkSmartPointer<vtkGeneralTransform>::New();
       composedResliceTransform->Identity();
       composedResliceTransform->Concatenate(
         inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->GetVtkTransform()->GetLinearInverse() );
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkAbstractTransform()
         );
 
       m_Reslicer->SetResliceTransform( composedResliceTransform );
 
       // Set background level to BLACK instead of translucent, to avoid
-      // boundary artifacts (see Geometry2DDataVtkMapper3D)
+      // boundary artifacts (see PlaneGeometryDataVtkMapper3D)
       m_Reslicer->SetBackgroundLevel( -1023 );
     }
     else
     {
       itkExceptionMacro("mitk::ExtractSliceFilter: No fitting geometry for reslice axis!");
       return;
     }
 
   }
 
   if(m_ResliceTransform.IsNotNull()){
     //if the resliceTransform is set the reslice axis are recalculated.
     //Thus the geometry information is not fitting. Therefor a unitSpacingFilter
     //is used to set up a global spacing of 1 and compensate the transform.
     vtkSmartPointer<vtkImageChangeInformation> unitSpacingImageFilter = vtkSmartPointer<vtkImageChangeInformation>::New() ;
     unitSpacingImageFilter->ReleaseDataFlagOn();
 
     unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
     unitSpacingImageFilter->SetInputData( input->GetVtkImageData(m_TimeStep) );
 
     m_Reslicer->SetInputConnection(unitSpacingImageFilter->GetOutputPort() );
   }
   else
   {
     //if no tranform is set the image can be used directly
     m_Reslicer->SetInputData(input->GetVtkImageData(m_TimeStep));
   }
 
 
   /*setup the plane where vktImageReslice extracts the slice*/
 
   //ResliceAxesOrigin is the ancor point of the plane
   double originInVtk[3];
   itk2vtk(origin, originInVtk);
   m_Reslicer->SetResliceAxesOrigin(originInVtk);
 
 
   //the cosines define the plane: x and y are the direction vectors, n is the planes normal
   //this specifies a matrix 3x3
   //  x1 y1 n1
   //  x2 y2 n2
   //  x3 y3 n3
   double cosines[9];
 
   vnl2vtk(right.GetVnlVector(), cosines);//x
 
   vnl2vtk(bottom.GetVnlVector(), cosines + 3);//y
 
   vnl2vtk(normal.GetVnlVector(), cosines + 6);//n
 
   m_Reslicer->SetResliceAxesDirectionCosines(cosines);
 
 
   //we only have one slice, not a volume
   m_Reslicer->SetOutputDimensionality(m_OutputDimension);
 
 
   //set the interpolation mode for slicing
   switch(this->m_InterpolationMode){
     case RESLICE_NEAREST:
       m_Reslicer->SetInterpolationModeToNearestNeighbor();
       break;
     case RESLICE_LINEAR:
       m_Reslicer->SetInterpolationModeToLinear();
       break;
     case RESLICE_CUBIC:
       m_Reslicer->SetInterpolationModeToCubic();
       break;
     default:
       //the default interpolation used by mitk
       m_Reslicer->SetInterpolationModeToNearestNeighbor();
   }
 
 
   /*========== BEGIN setup extent of the slice ==========*/
   int xMin, xMax, yMin, yMax;
 
   xMin = yMin = 0;
   xMax = static_cast< int >( extent[0]);
   yMax = static_cast< int >( extent[1]);
 
   double sliceBounds[6];
   if (m_WorldGeometry->GetReferenceGeometry())
   {
     for ( int i = 0; i < 6; ++i )
     {
       sliceBounds[i] = 0.0;
     }
 
     if (this->GetClippedPlaneBounds( m_WorldGeometry->GetReferenceGeometry(), planeGeometry, sliceBounds ))
     {
       // Calculate output extent (integer values)
       xMin = static_cast< int >( sliceBounds[0] / m_OutPutSpacing[0] + 0.5 );
       xMax = static_cast< int >( sliceBounds[1] / m_OutPutSpacing[0] + 0.5 );
       yMin = static_cast< int >( sliceBounds[2] / m_OutPutSpacing[1] + 0.5 );
       yMax = static_cast< int >( sliceBounds[3] / m_OutPutSpacing[1] + 0.5 );
     } // ELSE we use the default values
   }
 
   // Set the output extents! First included pixel index and last included pixel index
   // xMax and yMax are one after the last pixel. so they have to be decremented by 1.
   // In case we have a 2D image, xMax or yMax might be 0. in this case, do not decrement, but take 0.
 
   m_Reslicer->SetOutputExtent(xMin, std::max(0, xMax-1), yMin, std::max(0, yMax-1), m_ZMin, m_ZMax );
   /*========== END setup extent of the slice ==========*/
 
 
   m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 );
 
   m_Reslicer->SetOutputSpacing( m_OutPutSpacing[0], m_OutPutSpacing[1], m_ZSpacing );
 
 
   //TODO check the following lines, they are responsible wether vtk error outputs appear or not
   m_Reslicer->UpdateWholeExtent(); //this produces a bad allocation error for 2D images
   //m_Reslicer->GetOutput()->UpdateInformation();
   //m_Reslicer->GetOutput()->SetUpdateExtentToWholeExtent();
 
   //start the pipeline
   m_Reslicer->Update();
 
   /*================ #END setup vtkImageRslice properties================*/
 
   if(m_VtkOutputRequested){
     return;
     //no converting to mitk
     //no mitk geometry will be set, as the output is vtkImageData only!!!
   }
   else
   {
     /*================ #BEGIN Get the slice from vtkImageReslice and convert it to mit::Image================*/
     vtkImageData* reslicedImage;
     reslicedImage = m_Reslicer->GetOutput();
 
 
     if(!reslicedImage)
     {
       itkWarningMacro(<<"Reslicer returned empty image");
       return;
     }
 
 
     mitk::Image::Pointer resultImage = this->GetOutput();
 
     //initialize resultimage with the specs of the vtkImageData object returned from vtkImageReslice
     if (reslicedImage->GetDataDimension() == 1)
     {
        // If original image was 2D, the slice might have an y extent of 0.
        // Still i want to ensure here that Image is 2D
          resultImage->Initialize(reslicedImage,1,-1,-1,1);
     }
     else
     {
        resultImage->Initialize(reslicedImage);
     }
 
 
     //transfer the voxel data
     resultImage->SetVolume(reslicedImage->GetScalarPointer());
 
 
     //set the geometry from current worldgeometry for the reusultimage
     //this is needed that the image has the correct mitk geometry
     //the originalGeometry is the Geometry of the result slice
 
 //    mitk::AffineGeometryFrame3D::Pointer originalGeometryAGF = m_WorldGeometry->Clone();
 //    PlaneGeometry::Pointer originalGeometry = dynamic_cast<PlaneGeometry*>( originalGeometryAGF.GetPointer() );
     PlaneGeometry::Pointer originalGeometry = m_WorldGeometry->Clone();
 
     originalGeometry->GetIndexToWorldTransform()->SetMatrix(m_WorldGeometry->GetIndexToWorldTransform()->GetMatrix());
 
     //the origin of the worldGeometry is transformed to center based coordinates to be an imageGeometry
     Point3D sliceOrigin = originalGeometry->GetOrigin();
 
     sliceOrigin += right * ( m_OutPutSpacing[0] * 0.5 );
     sliceOrigin += bottom * ( m_OutPutSpacing[1] * 0.5 );
 
     //a worldGeometry is no imageGeometry, thus it is manually set to true
     originalGeometry->ImageGeometryOn();
 
 
     /*At this point we have to adjust the geometry because the origin isn't correct.
     The wrong origin is related to the rotation of the current world geometry plane.
     This causes errors on transfering world to index coordinates. We just shift the
     origin in each direction about the amount of the expanding (needed while rotating
     the plane).
     */
     Vector3D axis0 = originalGeometry->GetAxisVector(0);
     Vector3D axis1 = originalGeometry->GetAxisVector(1);
     axis0.Normalize();
     axis1.Normalize();
 
 
     //adapt the origin. Note that for orthogonal planes the minima are '0' and thus the origin stays the same.
     sliceOrigin += (axis0 * (xMin * m_OutPutSpacing[0])) + (axis1 * (yMin * m_OutPutSpacing[1]));
 
     originalGeometry->SetOrigin(sliceOrigin);
 
     originalGeometry->Modified();
 
 
     resultImage->SetGeometry( originalGeometry );
 
 
     /*the bounds as well as the extent of the worldGeometry are not adapted correctly during crosshair rotation.
     This is only a quick fix and has to be evaluated.
     The new bounds are set via the max values of the calcuted slice extent. It will look like [ 0, x, 0, y, 0, 1].
     */
     mitk::BoundingBox::BoundsArrayType boundsCopy;
     boundsCopy[0] = boundsCopy[2] = boundsCopy[4] = 0;
     boundsCopy[5] = 1;
     boundsCopy[1] =  xMax - xMin;
     boundsCopy[3] =  yMax - yMin;
     resultImage->GetGeometry()->SetBounds(boundsCopy);
 
     /*================ #END Get the slice from vtkImageReslice and convert it to mitk Image================*/
   }
 }
 
 
 bool mitk::ExtractSliceFilter::GetClippedPlaneBounds(double bounds[6]){
 
   if(!m_WorldGeometry || !this->GetInput())
     return false;
 
   return this->GetClippedPlaneBounds(m_WorldGeometry->GetReferenceGeometry(), dynamic_cast< const PlaneGeometry * >( m_WorldGeometry ), bounds);
 
 }
 
 
 bool mitk::ExtractSliceFilter::GetClippedPlaneBounds( const BaseGeometry *boundingGeometry,
                                                      const PlaneGeometry *planeGeometry, double *bounds )
 {
   bool b =  mitk::PlaneClipping::CalculateClippedPlaneBounds(boundingGeometry, planeGeometry, bounds);
 
   return b;
 }
diff --git a/Core/Code/Algorithms/mitkExtractSliceFilter.h b/Core/Code/Algorithms/mitkExtractSliceFilter.h
index 978e70416a..9f6e1f75e9 100644
--- a/Core/Code/Algorithms/mitkExtractSliceFilter.h
+++ b/Core/Code/Algorithms/mitkExtractSliceFilter.h
@@ -1,175 +1,175 @@
 /*===================================================================
 
 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 mitkExtractSliceFilter_h_Included
 #define mitkExtractSliceFilter_h_Included
 
 
 #include "MitkCoreExports.h"
 #include "mitkImageToImageFilter.h"
 #include <vtkSmartPointer.h>
 
 #include <vtkImageReslice.h>
 #include <vtkMatrix4x4.h>
 #include <vtkImageData.h>
 #include <vtkPoints.h>
 #include <vtkTransform.h>
 #include <vtkAbstractTransform.h>
 
 namespace mitk
 {
   /**
   \brief ExtractSliceFilter extracts a 2D abitrary oriented slice from a 3D volume.
 
   The filter can reslice in all orthogonal planes such as sagittal, coronal and axial,
   and is also able to reslice a abitrary oriented oblique plane.
   Curved planes are specified via an AbstractTransformGeometry as the input worldgeometry.
 
   The convinient workflow is:
   1. Set an image as input.
-  2. Set the worldGeometry2D. This defines a grid where the slice is being extracted
+  2. Set the worldPlaneGeometry. This defines a grid where the slice is being extracted
   3. And then start the pipeline.
 
   There are a few more properties that can be set to modify the behavior of the slicing.
   The properties are:
   - interpolation mode either Nearestneighbor, Linear or Cubic.
   - a transform this is a convinient way to adapt the reslice axis for the case
   that the image is transformed e.g. rotated.
   - time step the time step in a times volume.
   - resample by geometry wether the resampling grid corresponds to the specs of the
   worldgeometry or is directly derived from the input image
 
   By default the properties are set to:
   - interpolation mode Nearestneighbor.
   - a transform NULL (No transform is set).
   - time step 0.
   - resample by geometry false (Corresponds to input image).
   */
   class MITK_CORE_EXPORT ExtractSliceFilter : public ImageToImageFilter
   {
   public:
 
     mitkClassMacro(ExtractSliceFilter, ImageToImageFilter);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     mitkNewMacro1Param(Self, vtkImageReslice*);
 
     /** \brief Set the axis where to reslice at.*/
     void SetWorldGeometry(const PlaneGeometry* geometry ){
        this->m_WorldGeometry = geometry;
        this->Modified(); }
 
     /** \brief Set the time step in the 4D volume */
     void SetTimeStep( unsigned int timestep){ this->m_TimeStep = timestep; }
     unsigned int GetTimeStep(){ return this->m_TimeStep; }
 
     /** \brief Set a transform for the reslice axes.
     * This transform is needed if the image volume itself is transformed. (Effects the reslice axis)
     */
     void SetResliceTransformByGeometry(const BaseGeometry* transform){ this->m_ResliceTransform = transform; }
 
     /** \brief Resampling grid corresponds to: false->image    true->worldgeometry*/
     void SetInPlaneResampleExtentByGeometry(bool inPlaneResampleExtentByGeometry){ this->m_InPlaneResampleExtentByGeometry = inPlaneResampleExtentByGeometry; }
 
     /** \brief Sets the output dimension of the slice*/
     void SetOutputDimensionality(unsigned int dimension){ this->m_OutputDimension = dimension; }
 
     /** \brief Set the spacing in z direction manually.
     * Required if the outputDimension is > 2.
     */
     void SetOutputSpacingZDirection(double zSpacing){ this->m_ZSpacing = zSpacing; }
 
     /** \brief Set the extent in pixel for direction z manualy.
     Required if the output dimension is > 2.
     */
     void SetOutputExtentZDirection(int zMin, int zMax) { this->m_ZMin = zMin; this->m_ZMax = zMax; }
 
     /** \brief Get the bounding box of the slice [xMin, xMax, yMin, yMax, zMin, zMax]
     * The method uses the input of the filter to calculate the bounds.
     * It is recommended to use
-    * GetClippedPlaneBounds(const Geometry3D*, const PlaneGeometry*, double*)
+    * GetClippedPlaneBounds(const BaseGeometry*, const PlaneGeometry*, double*)
     * if you are not sure about the input.
     */
     bool GetClippedPlaneBounds(double bounds[6]);
 
     /** \brief Get the bounding box of the slice [xMin, xMax, yMin, yMax, zMin, zMax]*/
     bool GetClippedPlaneBounds( const BaseGeometry *boundingGeometry,
       const PlaneGeometry *planeGeometry, double *bounds );
 
     /** \brief Get the spacing of the slice. returns mitk::ScalarType[2] */
     mitk::ScalarType* GetOutputSpacing();
 
     /** \brief Get Output as vtkImageData.
     * Note:
     * SetVtkOutputRequest(true) has to be called at least once before
     * GetVtkOutput(). Otherwise the output is empty for the first update step.
     */
     vtkImageData* GetVtkOutput(){ m_VtkOutputRequested = true; return m_Reslicer->GetOutput(); }
 
     /** Set VtkOutPutRequest to suppress the convertion of the image.
     * It is suggested to use this with GetVtkOutput().
     * Note:
     * SetVtkOutputRequest(true) has to be called at least once before
     * GetVtkOutput(). Otherwise the output is empty for the first update step.
     */
     void SetVtkOutputRequest(bool isRequested){ m_VtkOutputRequested = isRequested; }
 
     /** \brief Get the reslices axis matrix.
     * Note: the axis are recalculated when calling SetResliceTransformByGeometry.
     */
     vtkMatrix4x4* GetResliceAxes(){
       return this->m_Reslicer->GetResliceAxes();
     }
 
     enum ResliceInterpolation { RESLICE_NEAREST=0, RESLICE_LINEAR=1, RESLICE_CUBIC=3 };
 
     void SetInterpolationMode( ExtractSliceFilter::ResliceInterpolation interpolation){ this->m_InterpolationMode = interpolation; }
 
   protected:
     ExtractSliceFilter(vtkImageReslice* reslicer = NULL);
     virtual ~ExtractSliceFilter();
 
     virtual void GenerateData();
     virtual void GenerateOutputInformation();
     virtual void GenerateInputRequestedRegion();
 
     const PlaneGeometry* m_WorldGeometry;
     vtkSmartPointer<vtkImageReslice> m_Reslicer;
 
     unsigned int m_TimeStep;
 
     unsigned int m_OutputDimension;
 
     double m_ZSpacing;
 
     int m_ZMin;
 
     int m_ZMax;
 
     ResliceInterpolation m_InterpolationMode;
 
     BaseGeometry::ConstPointer m_ResliceTransform;
 
     bool m_InPlaneResampleExtentByGeometry;//Resampling grid corresponds to:  false->image    true->worldgeometry
 
     mitk::ScalarType* m_OutPutSpacing;
 
     bool m_VtkOutputRequested;
   };
 }
 
 #endif // mitkExtractSliceFilter_h_Included
diff --git a/Core/Code/Algorithms/mitkImageSliceSelector.cpp b/Core/Code/Algorithms/mitkImageSliceSelector.cpp
index 5fdf29436f..173c1c99ac 100644
--- a/Core/Code/Algorithms/mitkImageSliceSelector.cpp
+++ b/Core/Code/Algorithms/mitkImageSliceSelector.cpp
@@ -1,77 +1,77 @@
 /*===================================================================
 
 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 "mitkImageSliceSelector.h"
 
 
 void mitk::ImageSliceSelector::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input  = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   output->Initialize(input->GetPixelType(), 2, input->GetDimensions());
 
   if( (unsigned int)m_SliceNr >= input->GetDimension(2) )
   {
     m_SliceNr = input->GetDimension(2)-1;
   }
 
   if( (unsigned int)m_TimeNr >= input->GetDimension(3) )
   {
     m_TimeNr = input->GetDimension(3)-1;
   }
 
   // initialize geometry
-  output->SetGeometry(dynamic_cast<BaseGeometry*>(input->GetSlicedGeometry(m_TimeNr)->GetGeometry2D(m_SliceNr)->Clone().GetPointer()));
+  output->SetGeometry(dynamic_cast<BaseGeometry*>(input->GetSlicedGeometry(m_TimeNr)->GetPlaneGeometry(m_SliceNr)->Clone().GetPointer()));
   output->SetPropertyList(input->GetPropertyList()->Clone());
 }
 
 void mitk::ImageSliceSelector::GenerateData()
 {
   SetSliceItem(GetSliceData(m_SliceNr, m_TimeNr, m_ChannelNr), 0);
 }
 
 mitk::ImageSliceSelector::ImageSliceSelector() : m_SliceNr(0), m_TimeNr(0), m_ChannelNr(0)
 {
 }
 
 
 mitk::ImageSliceSelector::~ImageSliceSelector()
 {
 }
 
 void mitk::ImageSliceSelector::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::ImageToImageFilter::InputImagePointer input =
     const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
   mitk::Image::Pointer output = this->GetOutput();
 
   Image::RegionType requestedRegion;
   requestedRegion = output->GetRequestedRegion();
   requestedRegion.SetIndex(2, m_SliceNr);
   requestedRegion.SetIndex(3, m_TimeNr);
   requestedRegion.SetIndex(4, m_ChannelNr);
   requestedRegion.SetSize(2, 1);
   requestedRegion.SetSize(3, 1);
   requestedRegion.SetSize(4, 1);
 
   input->SetRequestedRegion( & requestedRegion );
 }
diff --git a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp b/Core/Code/Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
similarity index 89%
rename from Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
rename to Core/Code/Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
index cbac51447a..a4d5df2f1d 100644
--- a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
+++ b/Core/Code/Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
@@ -1,447 +1,447 @@
 /*===================================================================
 
 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 "mitkGeometry2DDataToSurfaceFilter.h"
+#include "mitkPlaneGeometryDataToSurfaceFilter.h"
 #include "mitkSurface.h"
 #include "mitkGeometry3D.h"
-#include "mitkGeometry2DData.h"
+#include "mitkPlaneGeometryData.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkAbstractTransformGeometry.h"
 
 #include <vtkPolyData.h>
 #include <vtkPlaneSource.h>
 #include <vtkTransformPolyDataFilter.h>
 
 #include <vtkCubeSource.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTransform.h>
 #include <vtkGeneralTransform.h>
 #include <vtkPlane.h>
 #include <vtkPPolyDataNormals.h>
 #include <vtkCutter.h>
 #include <vtkStripper.h>
 #include <vtkTriangleFilter.h>
 #include <vtkBox.h>
 #include <vtkClipPolyData.h>
 #include <vtkTextureMapToPlane.h>
 
 
-mitk::Geometry2DDataToSurfaceFilter::Geometry2DDataToSurfaceFilter()
+mitk::PlaneGeometryDataToSurfaceFilter::PlaneGeometryDataToSurfaceFilter()
 : m_UseGeometryParametricBounds( true ), m_XResolution( 10 ),
   m_YResolution( 10 ), m_PlaceByGeometry( false ), m_UseBoundingBox( false )
 {
   m_PlaneSource = vtkPlaneSource::New();
   m_Transform = vtkTransform::New();
 
   m_CubeSource = vtkCubeSource::New();
   m_PolyDataTransformer = vtkTransformPolyDataFilter::New();
 
   m_Plane = vtkPlane::New();
   m_PlaneCutter = vtkCutter::New();
   m_PlaneStripper = vtkStripper::New();
   m_PlanePolyData = vtkPolyData::New();
   m_NormalsUpdater = vtkPPolyDataNormals::New();
   m_PlaneTriangler = vtkTriangleFilter::New();
   m_TextureMapToPlane = vtkTextureMapToPlane::New();
 
   m_Box = vtkBox::New();
   m_PlaneClipper = vtkClipPolyData::New();
 
   m_VtkTransformPlaneFilter = vtkTransformPolyDataFilter::New();
   m_VtkTransformPlaneFilter->SetInputConnection(m_PlaneSource->GetOutputPort() );
 }
 
 
-mitk::Geometry2DDataToSurfaceFilter::~Geometry2DDataToSurfaceFilter()
+mitk::PlaneGeometryDataToSurfaceFilter::~PlaneGeometryDataToSurfaceFilter()
 {
   m_PlaneSource->Delete();
   m_Transform->Delete();
 
   m_CubeSource->Delete();
   m_PolyDataTransformer->Delete();
 
   m_Plane->Delete();
   m_PlaneCutter->Delete();
   m_PlaneStripper->Delete();
   m_PlanePolyData->Delete();
   m_NormalsUpdater->Delete();
   m_PlaneTriangler->Delete();
   m_TextureMapToPlane->Delete();
 
   m_Box->Delete();
   m_PlaneClipper->Delete();
 
   m_VtkTransformPlaneFilter->Delete();
 }
 
 
-void mitk::Geometry2DDataToSurfaceFilter::GenerateOutputInformation()
+void mitk::PlaneGeometryDataToSurfaceFilter::GenerateOutputInformation()
 {
-  mitk::Geometry2DData::ConstPointer input = this->GetInput();
+  mitk::PlaneGeometryData::ConstPointer input = this->GetInput();
   mitk::Surface::Pointer output = this->GetOutput();
 
-  if ( input.IsNull() || (input->GetGeometry2D() == NULL)
-    || (input->GetGeometry2D()->IsValid() == false)
+  if ( input.IsNull() || (input->GetPlaneGeometry() == NULL)
+    || (input->GetPlaneGeometry()->IsValid() == false)
     || (m_UseBoundingBox && (m_BoundingBox.IsNull() || (m_BoundingBox->GetDiagonalLength2() < mitk::eps))) )
   {
     return;
   }
 
   Point3D origin;
   Point3D right, bottom;
 
   vtkPolyData *planeSurface = NULL;
 
 
-  // Does the Geometry2DData contain a PlaneGeometry?
-  if ( dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() ) != NULL )
+  // Does the PlaneGeometryData contain a PlaneGeometry?
+  if ( dynamic_cast< PlaneGeometry * >( input->GetPlaneGeometry() ) != NULL )
   {
     mitk::PlaneGeometry *planeGeometry =
-      dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() );
+      dynamic_cast< PlaneGeometry * >( input->GetPlaneGeometry() );
 
     if ( m_PlaceByGeometry )
     {
       // Let the output use the input geometry to appropriately transform the
       // coordinate system.
       mitk::Geometry3D::TransformType *affineTransform =
         planeGeometry->GetIndexToWorldTransform();
 
       TimeGeometry *timeGeometry = output->GetTimeGeometry();
       BaseGeometry *geometrie3d = timeGeometry->GetGeometryForTimeStep( 0 );
       geometrie3d->SetIndexToWorldTransform( affineTransform );
     }
 
     if ( !m_UseBoundingBox)
     {
       // We do not have a bounding box, so no clipping is required.
 
       if ( m_PlaceByGeometry )
       {
         // Derive coordinate axes and origin from input geometry extent
         origin.Fill( 0.0 );
         FillVector3D( right,  planeGeometry->GetExtent(0), 0.0, 0.0 );
         FillVector3D( bottom, 0.0, planeGeometry->GetExtent(1), 0.0 );
       }
       else
       {
         // Take the coordinate axes and origin directly from the input geometry.
         origin = planeGeometry->GetOrigin();
         right = planeGeometry->GetCornerPoint( false, true );
         bottom = planeGeometry->GetCornerPoint( true, false );
       }
 
       // Since the plane is planar, there is no need to subdivide the grid
       // (cf. AbstractTransformGeometry case)
       m_PlaneSource->SetXResolution( 1 );
       m_PlaneSource->SetYResolution( 1 );
 
       m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
       m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
       m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
       m_PlaneSource->Update();
       planeSurface = m_PlaneSource->GetOutput();
 
     }
     else
     {
       // Set up a cube with the extent and origin of the bounding box. This
       // cube will be clipped by a plane later on. The intersection of the
       // cube and the plane will be the surface we are interested in. Note
       // that the bounding box needs to be explicitly specified by the user
       // of this class, since it is not necessarily clear from the data
       // available herein which bounding box to use. In most cases, this
       // would be the bounding box of the input geometry's reference
       // geometry, but this is not an inevitable requirement.
       mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
       mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
       mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();
 
       m_CubeSource->SetXLength( boundingBoxMax[0] - boundingBoxMin[0] );
       m_CubeSource->SetYLength( boundingBoxMax[1] - boundingBoxMin[1] );
       m_CubeSource->SetZLength( boundingBoxMax[2] - boundingBoxMin[2] );
       m_CubeSource->SetCenter(
         boundingBoxCenter[0],
         boundingBoxCenter[1],
         boundingBoxCenter[2] );
 
 
       // Now we have to transform the cube, so that it will cut our plane
       // appropriately. (As can be seen below, the plane corresponds to the
       // z-plane in the coordinate system and is *not* transformed.) Therefore,
       // we get the inverse of the plane geometry's transform and concatenate
       // it with the transform of the reference geometry, if available.
       m_Transform->Identity();
       m_Transform->Concatenate(
         planeGeometry->GetVtkTransform()->GetLinearInverse()
       );
 
       BaseGeometry *referenceGeometry = planeGeometry->GetReferenceGeometry();
       if ( referenceGeometry )
       {
         m_Transform->Concatenate(
           referenceGeometry->GetVtkTransform()
         );
       }
 
       // Transform the cube accordingly (s.a.)
       m_PolyDataTransformer->SetInputConnection( m_CubeSource->GetOutputPort() );
       m_PolyDataTransformer->SetTransform( m_Transform );
 
       // Initialize the plane to clip the cube with, as lying on the z-plane
       m_Plane->SetOrigin( 0.0, 0.0, 0.0 );
       m_Plane->SetNormal( 0.0, 0.0, 1.0 );
 
       // Cut the plane with the cube.
       m_PlaneCutter->SetInputConnection( m_PolyDataTransformer->GetOutputPort() );
       m_PlaneCutter->SetCutFunction( m_Plane );
 
       // The output of the cutter must be converted into appropriate poly data.
       m_PlaneStripper->SetInputConnection( m_PlaneCutter->GetOutputPort() );
       m_PlaneStripper->Update();
 
       if ( m_PlaneStripper->GetOutput()->GetNumberOfPoints() < 3 )
       {
         return;
       }
 
       m_PlanePolyData->SetPoints( m_PlaneStripper->GetOutput()->GetPoints() );
       m_PlanePolyData->SetPolys( m_PlaneStripper->GetOutput()->GetLines() );
 
       m_PlaneTriangler->SetInputData( m_PlanePolyData );
 
 
       // Get bounds of the resulting surface and use it to generate the texture
       // mapping information
       m_PlaneTriangler->Update();
       m_PlaneTriangler->GetOutput()->ComputeBounds();
       double *surfaceBounds =
         m_PlaneTriangler->GetOutput()->GetBounds();
 
       origin[0] = surfaceBounds[0];
       origin[1] = surfaceBounds[2];
       origin[2] = surfaceBounds[4];
 
       right[0] = surfaceBounds[1];
       right[1] = surfaceBounds[2];
       right[2] = surfaceBounds[4];
 
       bottom[0] = surfaceBounds[0];
       bottom[1] = surfaceBounds[3];
       bottom[2] = surfaceBounds[4];
 
       // Now we tell the data how it shall be textured afterwards;
       // description see above.
       m_TextureMapToPlane->SetInputConnection( m_PlaneTriangler->GetOutputPort() );
       m_TextureMapToPlane->AutomaticPlaneGenerationOn();
       m_TextureMapToPlane->SetOrigin( origin[0], origin[1], origin[2] );
       m_TextureMapToPlane->SetPoint1( right[0], right[1], right[2] );
       m_TextureMapToPlane->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
       // Need to call update so that output data and bounds are immediately
       // available
       m_TextureMapToPlane->Update();
 
 
       // Return the output of this generation process
       planeSurface = dynamic_cast< vtkPolyData * >(
         m_TextureMapToPlane->GetOutput()
       );
     }
   }
 
-  // Does the Geometry2DData contain an AbstractTransformGeometry?
+  // Does the PlaneGeometryData contain an AbstractTransformGeometry?
   else if ( mitk::AbstractTransformGeometry *abstractGeometry =
-    dynamic_cast< AbstractTransformGeometry * >( input->GetGeometry2D() ) )
+    dynamic_cast< AbstractTransformGeometry * >( input->GetPlaneGeometry() ) )
   {
     // In the case of an AbstractTransformGeometry (which holds a possibly
     // non-rigid transform), we proceed slightly differently: since the
     // plane can be arbitrarily deformed, we need to transform it by the
     // abstract transform before clipping it. The setup for this is partially
     // done in the constructor.
     origin = abstractGeometry->GetPlane()->GetOrigin();
     right = origin + abstractGeometry->GetPlane()->GetAxisVector( 0 );
     bottom = origin + abstractGeometry->GetPlane()->GetAxisVector( 1 );
 
     // Define the plane
     m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
     m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
     m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
     // Set the plane's resolution (unlike for non-deformable planes, the plane
     // grid needs to have a certain resolution so that the deformation has the
     // desired effect).
     if ( m_UseGeometryParametricBounds )
     {
       m_PlaneSource->SetXResolution(
         (int)abstractGeometry->GetParametricExtent(0)
       );
       m_PlaneSource->SetYResolution(
         (int)abstractGeometry->GetParametricExtent(1)
       );
     }
     else
     {
       m_PlaneSource->SetXResolution( m_XResolution );
       m_PlaneSource->SetYResolution( m_YResolution );
     }
     if ( m_PlaceByGeometry )
     {
       // Let the output use the input geometry to appropriately transform the
       // coordinate system.
       mitk::Geometry3D::TransformType *affineTransform =
         abstractGeometry->GetIndexToWorldTransform();
 
       TimeGeometry *timeGeometry = output->GetTimeGeometry();
       BaseGeometry *g3d = timeGeometry->GetGeometryForTimeStep( 0 );
       g3d->SetIndexToWorldTransform( affineTransform );
 
       vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New();
       composedResliceTransform->Identity();
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkTransform()->GetLinearInverse() );
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkAbstractTransform()
         );
       // Use the non-rigid transform for transforming the plane.
       m_VtkTransformPlaneFilter->SetTransform(
         composedResliceTransform
       );
     }
     else
     {
       // Use the non-rigid transform for transforming the plane.
       m_VtkTransformPlaneFilter->SetTransform(
         abstractGeometry->GetVtkAbstractTransform()
       );
     }
 
     if ( m_UseBoundingBox )
     {
       mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
       mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
       //mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();
 
       m_Box->SetXMin( boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2] );
       m_Box->SetXMax( boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2] );
     }
     else
     {
       // Plane will not be clipped
       m_Box->SetXMin( -10000.0, -10000.0, -10000.0 );
       m_Box->SetXMax( 10000.0, 10000.0, 10000.0 );
     }
 
     m_Transform->Identity();
-    m_Transform->Concatenate( input->GetGeometry2D()->GetVtkTransform() );
+    m_Transform->Concatenate( input->GetPlaneGeometry()->GetVtkTransform() );
     m_Transform->PreMultiply();
 
     m_Box->SetTransform( m_Transform );
 
     m_PlaneClipper->SetInputConnection(m_VtkTransformPlaneFilter->GetOutputPort() );
     m_PlaneClipper->SetClipFunction( m_Box );
     m_PlaneClipper->GenerateClippedOutputOff(); // important to NOT generate normals data for clipped part
     m_PlaneClipper->InsideOutOn();
     m_PlaneClipper->SetValue( 0.0 );
     m_PlaneClipper->Update();
 
     planeSurface = m_PlaneClipper->GetOutput();
   }
 
   m_NormalsUpdater->SetInputData( planeSurface );
   m_NormalsUpdater->AutoOrientNormalsOn(); // that's the trick! Brings consistency between
                                           //  normals direction and front/back faces direction (see bug 1440)
   m_NormalsUpdater->ComputePointNormalsOn();
   m_NormalsUpdater->Update();
 
   output->SetVtkPolyData( m_NormalsUpdater->GetOutput() );
   output->CalculateBoundingBox();
 }
 
 
-void mitk::Geometry2DDataToSurfaceFilter::GenerateData()
+void mitk::PlaneGeometryDataToSurfaceFilter::GenerateData()
 {
   mitk::Surface::Pointer output = this->GetOutput();
 
   if (output.IsNull()) return;
   if (output->GetVtkPolyData()==NULL) return;
 
 //  output->GetVtkPolyData()->Update(); //VTK6_TODO vtk pipeline
 }
 
-const mitk::Geometry2DData *mitk::Geometry2DDataToSurfaceFilter::GetInput()
+const mitk::PlaneGeometryData *mitk::PlaneGeometryDataToSurfaceFilter::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
-  return static_cast<const mitk::Geometry2DData * >
+  return static_cast<const mitk::PlaneGeometryData * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 
-const mitk::Geometry2DData *
-mitk::Geometry2DDataToSurfaceFilter
+const mitk::PlaneGeometryData *
+mitk::PlaneGeometryDataToSurfaceFilter
 ::GetInput(unsigned int idx)
 {
-  return static_cast< const mitk::Geometry2DData * >
+  return static_cast< const mitk::PlaneGeometryData * >
     ( this->ProcessObject::GetInput(idx) );
 }
 
 
 void
-mitk::Geometry2DDataToSurfaceFilter
-::SetInput(const mitk::Geometry2DData *input)
+mitk::PlaneGeometryDataToSurfaceFilter
+::SetInput(const mitk::PlaneGeometryData *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 0,
-  const_cast< mitk::Geometry2DData * >( input )
+  const_cast< mitk::PlaneGeometryData * >( input )
   );
 }
 
 
 void
-mitk::Geometry2DDataToSurfaceFilter
-::SetInput(unsigned int index, const mitk::Geometry2DData *input)
+mitk::PlaneGeometryDataToSurfaceFilter
+::SetInput(unsigned int index, const mitk::PlaneGeometryData *input)
 {
   if( index+1 > this->GetNumberOfInputs() )
   {
     this->SetNumberOfRequiredInputs( index + 1 );
   }
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(index,
-    const_cast< mitk::Geometry2DData *>( input )
+    const_cast< mitk::PlaneGeometryData *>( input )
   );
 }
 
 
 void
-mitk::Geometry2DDataToSurfaceFilter
+mitk::PlaneGeometryDataToSurfaceFilter
 ::SetBoundingBox( const mitk::BoundingBox *boundingBox )
 {
   m_BoundingBox = boundingBox;
   this->UseBoundingBoxOn();
 }
 
 
 const mitk::BoundingBox *
-mitk::Geometry2DDataToSurfaceFilter
+mitk::PlaneGeometryDataToSurfaceFilter
 ::GetBoundingBox() const
 {
   return m_BoundingBox.GetPointer();
 }
diff --git a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.h b/Core/Code/Algorithms/mitkPlaneGeometryDataToSurfaceFilter.h
similarity index 91%
rename from Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.h
rename to Core/Code/Algorithms/mitkPlaneGeometryDataToSurfaceFilter.h
index 0e2f95f72e..cb8be87660 100644
--- a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.h
+++ b/Core/Code/Algorithms/mitkPlaneGeometryDataToSurfaceFilter.h
@@ -1,228 +1,228 @@
 /*===================================================================
 
 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 MITKGEOMETRY2DDATATOSURFACEDATAFILTER_H_HEADER_INCLUDED_C10B22CD
 #define MITKGEOMETRY2DDATATOSURFACEDATAFILTER_H_HEADER_INCLUDED_C10B22CD
 
 #include "mitkSurfaceSource.h"
 #include "mitkGeometry3D.h"
 #include "vtkSystemIncludes.h"
 
 class vtkPlaneSource;
 class vtkTransformPolyDataFilter;
 class vtkCubeSource;
 class vtkTransform;
 class vtkPlane;
 class vtkCutter;
 class vtkStripper;
 class vtkPolyData;
 class vtkPPolyDataNormals;
 class vtkTriangleFilter;
 class vtkTextureMapToPlane;
 class vtkBox;
 class vtkClipPolyData;
 
 namespace mitk {
 
-class Geometry2DData;
+class PlaneGeometryData;
 
-/** \brief Superclass of all classes having a Geometry2DData as input and
+/** \brief Superclass of all classes having a PlaneGeometryData as input and
  *  generating Images as output
  *
  *  Currently implemented for PlaneGeometry and AbstractTransformGeometry.
  *  Currently, this class does not really have subclasses, but does the job
  *  for itself. It checks which kind of PlaneGeometry is stored in the
- *  Geometry2DData and - if it knows how - it generates the respective
+ *  PlaneGeometryData and - if it knows how - it generates the respective
  *  Surface. Of course, this has the disadvantage that for any new type of
- *  PlaneGeometry this class (Geometry2DDataToSurfaceFilter) has to be
+ *  PlaneGeometry this class (PlaneGeometryDataToSurfaceFilter) has to be
  *  changed/extended. The idea is to move the type specific generation code in
  *  subclasses, and internally (within this class) use a factory to create an
  *  instance of the required subclass and delegate the surface generation to
  *  it.
  *
  *  \sa mitk::DeformablePlane
  *  \todo make extension easier
  *  \ingroup Process
  */
-class MITK_CORE_EXPORT Geometry2DDataToSurfaceFilter : public SurfaceSource
+class MITK_CORE_EXPORT PlaneGeometryDataToSurfaceFilter : public SurfaceSource
 {
   public:
-    mitkClassMacro(Geometry2DDataToSurfaceFilter, SurfaceSource);
+    mitkClassMacro(PlaneGeometryDataToSurfaceFilter, SurfaceSource);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     virtual void GenerateOutputInformation();
 
     virtual void GenerateData();
 
-    const Geometry2DData *GetInput(void);
-    const Geometry2DData *GetInput(unsigned int idx);
+    const PlaneGeometryData *GetInput(void);
+    const PlaneGeometryData *GetInput(unsigned int idx);
 
-    virtual void SetInput(const Geometry2DData *image);
+    virtual void SetInput(const PlaneGeometryData *image);
     using itk::ProcessObject::SetInput;
-    virtual void SetInput(unsigned int index, const Geometry2DData *image);
+    virtual void SetInput(unsigned int index, const PlaneGeometryData *image);
 
     /** \brief If \a true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space,
      *  otherwise use m_XResolution and m_YResolution
      */
     itkGetMacro(UseGeometryParametricBounds, bool);
     /** \brief If \a true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space,
      *  otherwise use m_XResolution and m_YResolution
      */
     itkSetMacro(UseGeometryParametricBounds, bool);
 
     /** \brief Get x-resolution in parameter space
      *
      *  The m_PlaneSource will create this many sub-rectangles
      *  in x-direction (see vtkPlaneSource::SetXResolution)
      *  \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
      *  the x-bounds of Geometry3D::GetParametricBounds() are used.
      *  \sa m_XResolution
      */
     itkGetMacro(XResolution, int);
     /** \brief Set x-resolution in parameter space
      *
      *  The m_PlaneSource will create this many sub-rectangles
      *  in x-direction (see vtkPlaneSource::SetXResolution)
      *  \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
      *  the x-bounds of Geometry3D::GetParametricBounds() are used.
      *  \sa m_XResolution
      */
     itkSetMacro(XResolution, int);
 
     /** \brief Get y-resolution in parameter space
      *
      *  The m_PlaneSource will create this many sub-rectangles
      *  in y-direction (see vtkPlaneSource::SetYResolution)
      *  \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
      *  the y-bounds of Geometry3D::GetParametricBounds() are used.
      *  \sa m_YResolution
      */
     itkGetMacro(YResolution, int);
 
     /** \brief Set y-resolution in parameter space
      *
      *  The m_PlaneSource will create this many sub-rectangles
      *  in y-direction (see vtkPlaneSource::SetYResolution)
      *  \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
      *  the y-bounds of Geometry3D::GetParametricBounds() are used.
      *  \sa m_YResolution
      */
     itkSetMacro(YResolution, int);
 
     /** \brief Get whether the Surface is at the origin and placed using the Geometry
      *
      *  Default is \a false, i.e., the transform of the Geometry is the identity, thus
      *  the points within the Surface are at their final position. Otherwise
      *  (m_PlaceByGeometry==\a true), the first cornerpoint of the created Surface is
      *  at the origin and the actual position is determined by the transform of the
      *  Geometry.
      *  \sa m_PlaceByGeometry
      */
     itkGetConstMacro(PlaceByGeometry, bool);
 
     /** \brief Set whether the Surface is at the origin and placed using the Geometry
      *
      *  Default is \a false, i.e., the transform of the Geometry is the identity, thus
      *  the points within the Surface are at their final position. Otherwise
      *  (m_PlaceByGeometry==\a true), the first cornerpoint of the created Surface is
      *  at the origin and the actual position is determined by the transform of the
      *  Geometry.
      *  \sa m_PlaceByGeometry
      */
     itkSetMacro(PlaceByGeometry, bool);
     itkBooleanMacro(PlaceByGeometry);
 
     itkGetConstMacro( UseBoundingBox, bool );
     itkSetMacro( UseBoundingBox, bool );
     itkBooleanMacro( UseBoundingBox );
 
     void SetBoundingBox( const BoundingBox *boundingBox );
     const BoundingBox *GetBoundingBox() const;
 
   protected:
 
-    Geometry2DDataToSurfaceFilter();
+    PlaneGeometryDataToSurfaceFilter();
 
-    virtual ~Geometry2DDataToSurfaceFilter();
+    virtual ~PlaneGeometryDataToSurfaceFilter();
 
     /** \brief Source to create the vtk-representation of the parameter space rectangle of the PlaneGeometry
      */
     vtkPlaneSource* m_PlaneSource;
 
     /** \brief Filter to create the vtk-representation of the PlaneGeometry, which is a
      *  transformation of the m_PlaneSource
      */
     vtkTransformPolyDataFilter* m_VtkTransformPlaneFilter;
 
     /** \brief If \a true, use Geometry3D::GetParametricBounds() to define the resolution in parameter space,
      *  otherwise use m_XResolution and m_YResolution
      */
     bool m_UseGeometryParametricBounds;
 
     /** \brief X-resolution in parameter space
      *
      *  The m_PlaneSource will create this many sub-rectangles
      *  in x-direction (see vtkPlaneSource::SetXResolution)
      *  \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
      *  the x-bounds of Geometry3D::GetParametricBounds() are used.
      *  \sa m_XResolution
      */
     int m_XResolution;
 
     /** \brief Y-resolution in parameter space
      *
      *  The m_PlaneSource will create this many sub-rectangles
      *  in y-direction (see vtkPlaneSource::SetYResolution)
      *  \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
      *  the y-bounds of Geometry3D::GetParametricBounds() are used.
      */
     int m_YResolution;
 
     /** \brief Define whether the Surface is at the origin and placed using the Geometry
      *
      *  Default is \a false, i.e., the transform of the Geometry is the identity, thus
      *  the points within the Surface are at their final position. Otherwise
      *  (m_PlaceByGeometry==\a true), the first cornerpoint of the created Surface is
      *  at the origin and the actual position is determined by the transform of the
      *  Geometry.
      */
     bool m_PlaceByGeometry;
 
     bool m_UseBoundingBox;
 
     BoundingBox::ConstPointer m_BoundingBox;
 
     vtkCubeSource *m_CubeSource;
     vtkTransform *m_Transform;
     vtkTransformPolyDataFilter *m_PolyDataTransformer;
 
     vtkPlane *m_Plane;
     vtkCutter *m_PlaneCutter;
     vtkStripper *m_PlaneStripper;
     vtkPolyData *m_PlanePolyData;
     vtkPPolyDataNormals * m_NormalsUpdater;
     vtkTriangleFilter *m_PlaneTriangler;
     vtkTextureMapToPlane *m_TextureMapToPlane;
 
     vtkBox *m_Box;
     vtkClipPolyData *m_PlaneClipper;
 };
 
 } // namespace mitk
 
 #endif /* MITKGEOMETRY2DDATATOSURFACEDATAFILTER_H_HEADER_INCLUDED_C10B22CD */
diff --git a/Core/Code/Common/mitkCoreObjectFactory.cpp b/Core/Code/Common/mitkCoreObjectFactory.cpp
index f7a82a87ad..630b814b15 100644
--- a/Core/Code/Common/mitkCoreObjectFactory.cpp
+++ b/Core/Code/Common/mitkCoreObjectFactory.cpp
@@ -1,446 +1,446 @@
 /*===================================================================
 
 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 "mitkConfig.h"
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkAffineInteractor.h"
 #include "mitkColorProperty.h"
 #include "mitkDataNode.h"
 #include "mitkEnumerationProperty.h"
-#include "mitkGeometry2DData.h"
-#include "mitkGeometry2DDataMapper2D.h"
-#include "mitkGeometry2DDataVtkMapper3D.h"
+#include "mitkPlaneGeometryData.h"
+#include "mitkPlaneGeometryDataMapper2D.h"
+#include "mitkPlaneGeometryDataVtkMapper3D.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometryData.h"
 #include "mitkImage.h"
 #include <mitkImageVtkMapper2D.h>
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPointSet.h"
 #include "mitkPointSetVtkMapper2D.h"
 #include "mitkPointSetVtkMapper3D.h"
 #include "mitkProperties.h"
 #include "mitkPropertyList.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkStringProperty.h"
 #include "mitkSurface.h"
 #include "mitkSurface.h"
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkSurfaceVtkMapper3D.h"
 #include "mitkTimeGeometry.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 
 //#include "mitkPicFileIOFactory.h"
 #include "mitkPointSetIOFactory.h"
 #include "mitkItkImageFileIOFactory.h"
 #include "mitkSTLFileIOFactory.h"
 #include "mitkVtkSurfaceIOFactory.h"
 #include "mitkVtkImageIOFactory.h"
 #include "mitkVtiFileIOFactory.h"
 //#include "mitkPicVolumeTimeSeriesIOFactory.h"
 
 #include "mitkImageWriterFactory.h"
 #include "mitkImageWriter.h"
 #include "mitkPointSetWriterFactory.h"
 #include "mitkSurfaceVtkWriterFactory.h"
 
 void mitk::CoreObjectFactory::RegisterExtraFactory(CoreObjectFactoryBase* factory) {
   MITK_DEBUG << "CoreObjectFactory: registering extra factory of type " << factory->GetNameOfClass();
   m_ExtraFactories.insert(CoreObjectFactoryBase::Pointer(factory));
 }
 
 void mitk::CoreObjectFactory::UnRegisterExtraFactory(CoreObjectFactoryBase *factory)
 {
   MITK_DEBUG << "CoreObjectFactory: un-registering extra factory of type " << factory->GetNameOfClass();
   try
   {
     m_ExtraFactories.erase(factory);
   }
   catch( std::exception const& e)
   {
     MITK_ERROR << "Caugt exception while unregistering: " << e.what();
   }
 }
 
 mitk::CoreObjectFactory::Pointer mitk::CoreObjectFactory::GetInstance() {
   static mitk::CoreObjectFactory::Pointer instance;
   if (instance.IsNull())
   {
      instance = mitk::CoreObjectFactory::New();
   }
   return instance;
 }
 
 #include <mitkDataNodeFactory.h>
 
 void mitk::CoreObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   if(node==NULL)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if(image.IsNotNull() && image->IsInitialized())
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
     mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
   }
 
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
   if(surface.IsNotNull())
   {
     mitk::SurfaceGLMapper2D::SetDefaultProperties(node);
     mitk::SurfaceVtkMapper3D::SetDefaultProperties(node);
   }
 
   mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
   if(pointSet.IsNotNull())
   {
     mitk::PointSetVtkMapper2D::SetDefaultProperties(node);
     mitk::PointSetVtkMapper3D::SetDefaultProperties(node);
   }
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
     (*it)->SetDefaultProperties(node);
   }
 }
 
 mitk::CoreObjectFactory::CoreObjectFactory()
   : m_PointSetIOFactory(PointSetIOFactory::New().GetPointer())
   , m_STLFileIOFactory(STLFileIOFactory::New().GetPointer())
   , m_VtkSurfaceIOFactory(VtkSurfaceIOFactory::New().GetPointer())
   , m_VtkImageIOFactory(VtkImageIOFactory::New().GetPointer())
   , m_VtiFileIOFactory(VtiFileIOFactory::New().GetPointer())
   , m_ItkImageFileIOFactory(ItkImageFileIOFactory::New().GetPointer())
   , m_SurfaceVtkWriterFactory(SurfaceVtkWriterFactory::New().GetPointer())
   , m_PointSetWriterFactory(PointSetWriterFactory::New().GetPointer())
   , m_ImageWriterFactory(ImageWriterFactory::New().GetPointer())
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "CoreObjectFactory c'tor" << std::endl;
 
     itk::ObjectFactoryBase::RegisterFactory( m_PointSetIOFactory );
     itk::ObjectFactoryBase::RegisterFactory( m_STLFileIOFactory );
     itk::ObjectFactoryBase::RegisterFactory( m_VtkSurfaceIOFactory );
     itk::ObjectFactoryBase::RegisterFactory( m_VtkImageIOFactory );
     itk::ObjectFactoryBase::RegisterFactory( m_VtiFileIOFactory );
     itk::ObjectFactoryBase::RegisterFactory( m_ItkImageFileIOFactory );
 
     itk::ObjectFactoryBase::RegisterFactory( m_SurfaceVtkWriterFactory );
     itk::ObjectFactoryBase::RegisterFactory( m_PointSetWriterFactory );
     itk::ObjectFactoryBase::RegisterFactory( m_ImageWriterFactory );
 
     m_FileWriters.push_back(mitk::ImageWriter::New().GetPointer());
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::CoreObjectFactory::~CoreObjectFactory()
 {
   itk::ObjectFactoryBase::UnRegisterFactory( m_PointSetIOFactory );
   itk::ObjectFactoryBase::UnRegisterFactory( m_STLFileIOFactory );
   itk::ObjectFactoryBase::UnRegisterFactory( m_VtkSurfaceIOFactory );
   itk::ObjectFactoryBase::UnRegisterFactory( m_VtkImageIOFactory );
   itk::ObjectFactoryBase::UnRegisterFactory( m_VtiFileIOFactory );
   itk::ObjectFactoryBase::UnRegisterFactory( m_ItkImageFileIOFactory );
 
   itk::ObjectFactoryBase::UnRegisterFactory( m_SurfaceVtkWriterFactory );
   itk::ObjectFactoryBase::UnRegisterFactory( m_PointSetWriterFactory );
   itk::ObjectFactoryBase::UnRegisterFactory( m_ImageWriterFactory );
 }
 
 mitk::Mapper::Pointer mitk::CoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = NULL;
   mitk::Mapper::Pointer tmpMapper = NULL;
 
   // check whether extra factories provide mapper
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
     tmpMapper = (*it)->CreateMapper(node,id);
     if(tmpMapper.IsNotNull())
       newMapper = tmpMapper;
   }
 
   if (newMapper.IsNull())
   {
 
     mitk::BaseData *data = node->GetData();
 
     if ( id == mitk::BaseRenderer::Standard2D )
     {
       if((dynamic_cast<Image*>(data)!=NULL))
       {
         newMapper = mitk::ImageVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
-      else if((dynamic_cast<Geometry2DData*>(data)!=NULL))
+      else if((dynamic_cast<PlaneGeometryData*>(data)!=NULL))
       {
-        newMapper = mitk::Geometry2DDataMapper2D::New();
+        newMapper = mitk::PlaneGeometryDataMapper2D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<Surface*>(data)!=NULL))
       {
         newMapper = mitk::SurfaceGLMapper2D::New();
         // cast because SetDataNode is not virtual
         mitk::SurfaceGLMapper2D *castedMapper = dynamic_cast<mitk::SurfaceGLMapper2D*>(newMapper.GetPointer());
         castedMapper->SetDataNode(node);
       }
       else if((dynamic_cast<PointSet*>(data)!=NULL))
       {
         newMapper = mitk::PointSetVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
     }
     else if ( id == mitk::BaseRenderer::Standard3D )
     {
       if((dynamic_cast<Image*>(data) != NULL))
       {
         newMapper = mitk::VolumeDataVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
-      else if((dynamic_cast<Geometry2DData*>(data)!=NULL))
+      else if((dynamic_cast<PlaneGeometryData*>(data)!=NULL))
       {
-        newMapper = mitk::Geometry2DDataVtkMapper3D::New();
+        newMapper = mitk::PlaneGeometryDataVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<Surface*>(data)!=NULL))
       {
         newMapper = mitk::SurfaceVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<PointSet*>(data)!=NULL))
       {
         newMapper = mitk::PointSetVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
     }
   }
 
   return newMapper;
 }
 
 /*
 // @deprecated
 //
 #define EXTERNAL_FILE_EXTENSIONS \
     "All known formats(*.dcm *.DCM *.dc3 *.DC3 *.gdcm *.ima *.mhd *.mps *.nii *.pic *.pic.gz *.bmp *.png *.jpg *.tiff *.pvtk *.stl *.vtk *.vtp *.vtu *.obj *.vti *.hdr *.nrrd *.nhdr );;" \
     "DICOM files(*.dcm *.DCM *.dc3 *.DC3 *.gdcm);;" \
     "DKFZ Pic (*.seq *.pic *.pic.gz *.seq.gz);;" \
     "NRRD Vector Images (*.nrrd *.nhdr);;" \
     "Point sets (*.mps);;" \
     "Sets of 2D slices (*.pic *.pic.gz *.bmp *.png *.dcm *.gdcm *.ima *.tiff);;" \
     "Surface files (*.stl *.vtk *.vtp *.obj);;" \
     "NIfTI format (*.nii)"
 
 #define SAVE_FILE_EXTENSIONS "all (*.pic *.mhd *.vtk *.vti *.hdr *.png *.tiff *.jpg *.hdr *.bmp *.dcm *.gipl *.nii *.nrrd *.nhdr *.spr *.lsm *.dwi *.hdwi *.qbi *.hqbi)"
 */
 
 /**
  * @brief This method gets the supported (open) file extensions as string. This string is can then used by the QT QFileDialog widget.
  * @return The c-string that contains the file extensions
  *
  */
 const char* mitk::CoreObjectFactory::GetFileExtensions()
 {
   MultimapType aMap;
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
   {
     aMap = (*it)->GetFileExtensionsMap();
     this->MergeFileExtensions(m_FileExtensionsMap, aMap);
   }
   this->CreateFileExtensions(m_FileExtensionsMap, m_FileExtensions);
   return m_FileExtensions.c_str();
 }
 
 /**
  * @brief Merge the input map into the fileExtensionsMap. Duplicate entries are removed
  * @param fileExtensionsMap the existing map, it contains value pairs like ("*.dcm", "DICOM files"),("*.dc3", "DICOM files").
  *                          This map is extented/merged with the values from the input map.
  * @param inputMap the input map, it contains value pairs like ("*.dcm", "DICOM files"),("*.dc3", "DICOM files") returned by
  *                 the extra factories.
  *
  */
 void mitk::CoreObjectFactory::MergeFileExtensions(MultimapType& fileExtensionsMap, MultimapType inputMap)
 {
   bool duplicateFound = false;
   std::pair<MultimapType::iterator, MultimapType::iterator> pairOfIter;
   for (MultimapType::iterator it = inputMap.begin(); it != inputMap.end(); ++it)
   {
     duplicateFound = false;
     pairOfIter = fileExtensionsMap.equal_range((*it).first);
     for (MultimapType::iterator it2 = pairOfIter.first; it2 != pairOfIter.second; ++it2)
     {
       //cout << "  [" << (*it).first << ", " << (*it).second << "]" << endl;
       std::string aString = (*it2).second;
       if (aString.compare((*it).second) == 0)
       {
         //cout << "  DUP!! [" << (*it).first << ", " << (*it).second << "]" << endl;
         duplicateFound = true;
         break;
       }
     }
     if (!duplicateFound)
     {
       fileExtensionsMap.insert(std::pair<std::string, std::string>((*it).first, (*it).second));
     }
   }
 }
 
 /**
  * @brief get the defined (open) file extension map
  * @return the defined (open) file extension map
  */
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 /**
  * @brief initialize the file extension entries for open and save
  */
 void mitk::CoreObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DCM", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dc3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DC3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic.gz", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.mhd", "MetaImage"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq.gz", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze Format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img", "Analyze Format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img.gz", "Analyze Format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nrrd", "Nearly Raw Raster Data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nhdr", "NRRD with detached header"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.mps", "Point sets"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic.gz", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.bmp", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.png", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpg", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpeg", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.ima", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tiff", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tif", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.stl", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtp", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.obj", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "NIfTI format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii.gz", "NIfTI format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gipl", "UMDS GIPL Format Files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gipl.gz", "UMDS GIPL Format Files"));
 
   //m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "DKFZ Pic"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.mhd", "MetaImage"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Surface Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vti", "VTK Image Data Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze Format"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.png", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tiff", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tif", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpg", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpeg", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.bmp", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.gipl", "UMDS GIPL Format Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.gipl.gz", "UMDS compressed GIPL Format Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "NIfTI format"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii.gz", "NIfTI compressed format"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nrrd", "Nearly Raw Raster Data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nhdr", "NRRD with detached header"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.lsm", "Microscope Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
 
 }
 
 /**
  * @brief This method gets the supported (save) file extensions as string. This string is can then used by the QT QFileDialog widget.
  * @return The c-string that contains the (save) file extensions
  *
  */
 const char* mitk::CoreObjectFactory::GetSaveFileExtensions() {
   MultimapType aMap;
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
   {
     aMap = (*it)->GetSaveFileExtensionsMap();
     this->MergeFileExtensions(m_SaveFileExtensionsMap, aMap);
 
   }
   this->CreateFileExtensions(m_SaveFileExtensionsMap, m_SaveFileExtensions);
   return m_SaveFileExtensions.c_str();
 };
 
 /**
  * @brief get the defined (save) file extension map
  * @return the defined (save) file extension map
  */
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::GetFileWriters()
 {
   FileWriterList allWriters = m_FileWriters;
   //sort to merge lists later on
   typedef std::set<mitk::FileWriterWithInformation::Pointer> FileWriterSet;
   FileWriterSet fileWritersSet;
 
   fileWritersSet.insert(allWriters.begin(), allWriters.end());
 
   //collect all extra factories
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin();
        it != m_ExtraFactories.end(); it++ )
   {
     FileWriterList list2 = (*it)->GetFileWriters();
 
     //add them to the sorted set
     fileWritersSet.insert(list2.begin(), list2.end());
   }
 
   //write back to allWriters to return a list
   allWriters.clear();
   allWriters.insert(allWriters.end(), fileWritersSet.begin(), fileWritersSet.end());
 
   return allWriters;
 }
 
 void mitk::CoreObjectFactory::MapEvent(const mitk::Event*, const int) {
 
 }
 
diff --git a/Core/Code/Controllers/mitkSliceNavigationController.cpp b/Core/Code/Controllers/mitkSliceNavigationController.cpp
index b1fd535666..b4ad225341 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,840 +1,840 @@
 /*===================================================================
 
 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 "mitkSliceNavigationController.h"
 #include "mitkBaseRenderer.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkOperation.h"
 #include "mitkOperationActor.h"
 #include "mitkStateEvent.h"
 #include "mitkCrosshairPositionEvent.h"
 #include "mitkPositionEvent.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkEventMapper.h"
 #include "mitkFocusManager.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkInteractionConst.h"
 #include "mitkPointOperation.h"
 #include "mitkPlaneOperation.h"
 #include "mitkUndoController.h"
 #include "mitkOperationEvent.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkStatusBar.h"
 
 #include "mitkApplyTransformMatrixOperation.h"
 
 #include "mitkMemoryUtilities.h"
 
 
 #include <itkCommand.h>
 
 namespace mitk {
 
 SliceNavigationController::SliceNavigationController( const char *type )
 : BaseController( type ),
   m_InputWorldGeometry3D( NULL ),
   m_InputWorldTimeGeometry( NULL ),
   m_CreatedWorldGeometry( NULL ),
   m_ViewDirection( Axial ),
   m_DefaultViewDirection( Axial ),
   m_RenderingManager( NULL ),
   m_Renderer( NULL ),
   m_Top( false ),
   m_FrontSide( false ),
   m_Rotated( false ),
   m_BlockUpdate( false ),
   m_SliceLocked( false ),
   m_SliceRotationLocked( false ),
   m_OldPos(0)
 {
   typedef itk::SimpleMemberCommand< SliceNavigationController > SNCCommandType;
   SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
 
   sliceStepperChangedCommand = SNCCommandType::New();
   timeStepperChangedCommand = SNCCommandType::New();
 
   sliceStepperChangedCommand->SetCallbackFunction(
     this, &SliceNavigationController::SendSlice );
 
   timeStepperChangedCommand->SetCallbackFunction(
     this, &SliceNavigationController::SendTime );
 
   m_Slice->AddObserver( itk::ModifiedEvent(), sliceStepperChangedCommand );
   m_Time->AddObserver( itk::ModifiedEvent(), timeStepperChangedCommand );
 
   m_Slice->SetUnitName( "mm" );
   m_Time->SetUnitName( "ms" );
 
   m_Top = false;
   m_FrontSide = false;
   m_Rotated = false;
 }
 
 
 SliceNavigationController::~SliceNavigationController()
 {
 }
 
 
 void
 SliceNavigationController::SetInputWorldGeometry3D( const BaseGeometry *geometry )
 {
   if ( geometry != NULL )
   {
     if ( const_cast< BoundingBox * >( geometry->GetBoundingBox())
          ->GetDiagonalLength2() < eps )
     {
       itkWarningMacro( "setting an empty bounding-box" );
       geometry = NULL;
     }
   }
   if ( m_InputWorldGeometry3D != geometry )
   {
     m_InputWorldGeometry3D = geometry;
     m_InputWorldTimeGeometry = NULL;
     this->Modified();
   }
 }
 
 void
 SliceNavigationController::SetInputWorldTimeGeometry( const TimeGeometry *geometry )
 {
   if ( geometry != NULL )
   {
     if ( const_cast< BoundingBox * >( geometry->GetBoundingBoxInWorld())
          ->GetDiagonalLength2() < eps )
     {
       itkWarningMacro( "setting an empty bounding-box" );
       geometry = NULL;
     }
   }
   if ( m_InputWorldTimeGeometry != geometry )
   {
     m_InputWorldTimeGeometry = geometry;
     m_InputWorldGeometry3D = NULL;
     this->Modified();
   }
 }
 
 RenderingManager *
 SliceNavigationController::GetRenderingManager() const
 {
   mitk::RenderingManager* renderingManager = m_RenderingManager.GetPointer();
 
   if (renderingManager != NULL)
     return renderingManager;
 
   if ( m_Renderer != NULL )
   {
     renderingManager = m_Renderer->GetRenderingManager();
 
     if (renderingManager != NULL)
       return renderingManager;
   }
 
   return mitk::RenderingManager::GetInstance();
 }
 
 
 void SliceNavigationController::SetViewDirectionToDefault()
 {
   m_ViewDirection = m_DefaultViewDirection;
 }
 
 const char* SliceNavigationController::GetViewDirectionAsString()
 {
     const char* viewDirectionString;
     switch(m_ViewDirection)
     {
     case 0:
         viewDirectionString = "Axial";
         break;
 
     case 1:
         viewDirectionString = "Sagittal";
         break;
 
     case 2:
         viewDirectionString = "Frontal";
         break;
 
     case 3:
         viewDirectionString = "Original";
         break;
 
     default:
         viewDirectionString = "No View Direction Available";
         break;
     }
     return viewDirectionString;
 }
 
 void SliceNavigationController::Update()
 {
   if ( !m_BlockUpdate )
   {
     if ( m_ViewDirection == Axial )
     {
       this->Update( Axial, false, false, true );
     }
     else
     {
       this->Update( m_ViewDirection );
     }
   }
 }
 void
 SliceNavigationController::Update(
   SliceNavigationController::ViewDirection viewDirection,
   bool top, bool frontside, bool rotated )
 {
   TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
 
   if( m_BlockUpdate ||
       ( m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull() ) ||
       ( (worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0) )
     )
   {
     return;
   }
 
   m_BlockUpdate = true;
 
   if ( m_InputWorldTimeGeometry.IsNotNull() &&
     m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime() )
   {
     Modified();
   }
   if ( m_InputWorldGeometry3D.IsNotNull() &&
     m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime() )
   {
     Modified();
   }
   this->SetViewDirection( viewDirection );
   this->SetTop( top );
   this->SetFrontSide( frontside );
   this->SetRotated( rotated );
 
   if ( m_LastUpdateTime < GetMTime() )
   {
     m_LastUpdateTime = GetMTime();
 
     // initialize the viewplane
     SlicedGeometry3D::Pointer slicedWorldGeometry = NULL;
     BaseGeometry::ConstPointer currentGeometry = NULL;
     if (m_InputWorldTimeGeometry.IsNotNull())
       if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
         currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
       else
         currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
     else
       currentGeometry = m_InputWorldGeometry3D;
 
     m_CreatedWorldGeometry = NULL;
     switch ( viewDirection )
     {
     case Original:
       if ( worldTimeGeometry.IsNotNull())
       {
         m_CreatedWorldGeometry = worldTimeGeometry->Clone();
 
         worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
 
         slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
           m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).GetPointer() );
 
         if ( slicedWorldGeometry.IsNotNull() )
         {
           break;
         }
       }
       else
       {
         const SlicedGeometry3D *worldSlicedGeometry =
           dynamic_cast< const SlicedGeometry3D * >(
             currentGeometry.GetPointer());
 
         if ( worldSlicedGeometry != NULL )
         {
           slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
             currentGeometry->Clone().GetPointer());
           break;
         }
       }
       //else: use Axial: no "break" here!!
 
     case Axial:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes(
         currentGeometry, PlaneGeometry::Axial,
         top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Frontal:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes( currentGeometry,
         PlaneGeometry::Frontal, top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Sagittal:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes( currentGeometry,
         PlaneGeometry::Sagittal, top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
     default:
       itkExceptionMacro("unknown ViewDirection");
     }
 
     m_Slice->SetPos( 0 );
     m_Slice->SetSteps( (int)slicedWorldGeometry->GetSlices() );
 
     if ( m_CreatedWorldGeometry.IsNull() )
     {
       // initialize TimeGeometry
       m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
     }
     if ( worldTimeGeometry.IsNull())
     {
       m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
       dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, 1);
       m_Time->SetSteps( 0 );
       m_Time->SetPos( 0 );
       m_Time->InvalidateRange();
     }
     else
     {
       m_BlockUpdate = true;
       m_Time->SetSteps( worldTimeGeometry->CountTimeSteps() );
       m_Time->SetPos( 0 );
 
       const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
       m_Time->SetRange( timeBounds[0], timeBounds[1] );
 
       m_BlockUpdate = false;
 
       assert( worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).IsNotNull() );
 
       slicedWorldGeometry->SetTimeBounds(
         worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() )->GetTimeBounds() );
 
       //@todo implement for non-evenly-timed geometry!
       m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
       dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, worldTimeGeometry->CountTimeSteps());
     }
   }
 
   // unblock update; we may do this now, because if m_BlockUpdate was already
   // true before this method was entered, then we will never come here.
   m_BlockUpdate = false;
 
   // Send the geometry. Do this even if nothing was changed, because maybe
   // Update() was only called to re-send the old geometry and time/slice data.
   this->SendCreatedWorldGeometry();
   this->SendSlice();
   this->SendTime();
 
   // Adjust the stepper range of slice stepper according to geometry
   this->AdjustSliceStepperRange();
 }
 
 void
 SliceNavigationController::SendCreatedWorldGeometry()
 {
   // Send the geometry. Do this even if nothing was changed, because maybe
   // Update() was only called to re-send the old geometry.
   if ( !m_BlockUpdate )
   {
     this->InvokeEvent( GeometrySendEvent(m_CreatedWorldGeometry, 0) );
   }
 }
 
 void
 SliceNavigationController::SendCreatedWorldGeometryUpdate()
 {
   if ( !m_BlockUpdate )
   {
     this->InvokeEvent(
       GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
   }
 }
 
 void
 SliceNavigationController::SendSlice()
 {
   if ( !m_BlockUpdate )
   {
     if ( m_CreatedWorldGeometry.IsNotNull() )
     {
       this->InvokeEvent(
         GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
 
       // send crosshair event
       crosshairPositionEvent.Send();
 
       // Request rendering update for all views
       this->GetRenderingManager()->RequestUpdateAll();
     }
   }
 }
 
 void
 SliceNavigationController::SendTime()
 {
   if ( !m_BlockUpdate )
   {
     if ( m_CreatedWorldGeometry.IsNotNull() )
     {
       this->InvokeEvent(
         GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()) );
 
       // Request rendering update for all views
       this->GetRenderingManager()->RequestUpdateAll();
     }
   }
 }
 
 void
 SliceNavigationController::SetGeometry( const itk::EventObject & )
 {
 }
 
 void
 SliceNavigationController
 ::SetGeometryTime( const itk::EventObject &geometryTimeEvent )
 {
   const SliceNavigationController::GeometryTimeEvent *timeEvent =
     dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(
       &geometryTimeEvent);
 
   assert( timeEvent != NULL );
 
   TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
   assert( timeGeometry != NULL );
 
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
     int timeStep = (int) timeEvent->GetPos();
     ScalarType timeInMS;
     timeInMS = timeGeometry->TimeStepToTimePoint( timeStep );
     timeStep = m_CreatedWorldGeometry->TimePointToTimeStep( timeInMS );
     this->GetTime()->SetPos( timeStep );
   }
 }
 
 void
 SliceNavigationController
 ::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
 {
   const SliceNavigationController::GeometrySliceEvent* sliceEvent =
     dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(
       &geometrySliceEvent);
   assert(sliceEvent!=NULL);
 
   this->GetSlice()->SetPos(sliceEvent->GetPos());
 }
 
 void
 SliceNavigationController::SelectSliceByPoint( const Point3D &point )
 {
   //@todo add time to PositionEvent and use here!!
   SlicedGeometry3D* slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
     m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).GetPointer() );
 
   if ( slicedWorldGeometry )
   {
     int bestSlice = -1;
     double bestDistance = itk::NumericTraits<double>::max();
 
     int s, slices;
     slices = slicedWorldGeometry->GetSlices();
     if ( slicedWorldGeometry->GetEvenlySpaced() )
     {
-      mitk::PlaneGeometry *plane = slicedWorldGeometry->GetGeometry2D( 0 );
+      mitk::PlaneGeometry *plane = slicedWorldGeometry->GetPlaneGeometry( 0 );
 
       const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
 
       Point3D projectedPoint;
       plane->Project( point, projectedPoint );
 
       // Check whether the point is somewhere within the slice stack volume;
       // otherwise, the defualt slice (0) will be selected
       if ( direction[0] * (point[0] - projectedPoint[0])
          + direction[1] * (point[1] - projectedPoint[1])
          + direction[2] * (point[2] - projectedPoint[2]) >= 0 )
       {
         bestSlice = (int)(plane->Distance( point )
           / slicedWorldGeometry->GetSpacing()[2] + 0.5);
       }
     }
     else
     {
       Point3D projectedPoint;
       for ( s = 0; s < slices; ++s )
       {
-        slicedWorldGeometry->GetGeometry2D( s )->Project( point, projectedPoint );
+        slicedWorldGeometry->GetPlaneGeometry( s )->Project( point, projectedPoint );
         Vector3D distance = projectedPoint - point;
         ScalarType currentDistance = distance.GetSquaredNorm();
 
         if ( currentDistance < bestDistance )
         {
           bestDistance = currentDistance;
           bestSlice = s;
         }
       }
     }
     if ( bestSlice >= 0 )
     {
       this->GetSlice()->SetPos( bestSlice );
     }
     else
     {
       this->GetSlice()->SetPos( 0 );
     }
     this->SendCreatedWorldGeometryUpdate();
   }
 }
 
 
 void
 SliceNavigationController::ReorientSlices( const Point3D &point,
   const Vector3D &normal )
 {
   PlaneOperation op( OpORIENT, point, normal );
 
   m_CreatedWorldGeometry->ExecuteOperation( &op );
 
   this->SendCreatedWorldGeometryUpdate();
 }
 
 void SliceNavigationController::ReorientSlices(const mitk::Point3D &point,
    const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1 )
 {
    PlaneOperation op( OpORIENT, point, axisVec0, axisVec1 );
 
    m_CreatedWorldGeometry->ExecuteOperation( &op );
 
    this->SendCreatedWorldGeometryUpdate();
 }
 
 mitk::TimeGeometry *
 SliceNavigationController::GetCreatedWorldGeometry()
 {
   return m_CreatedWorldGeometry;
 }
 
 const mitk::BaseGeometry *
 SliceNavigationController::GetCurrentGeometry3D()
 {
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
     return m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() );
   }
   else
   {
     return NULL;
   }
 }
 
 
 const mitk::PlaneGeometry *
 SliceNavigationController::GetCurrentPlaneGeometry()
 {
   const mitk::SlicedGeometry3D *slicedGeometry =
     dynamic_cast< const mitk::SlicedGeometry3D * >
       ( this->GetCurrentGeometry3D() );
 
   if ( slicedGeometry )
   {
     const mitk::PlaneGeometry *planeGeometry =
       dynamic_cast< mitk::PlaneGeometry * >
-        ( slicedGeometry->GetGeometry2D(this->GetSlice()->GetPos()) );
+        ( slicedGeometry->GetPlaneGeometry(this->GetSlice()->GetPos()) );
     return planeGeometry;
   }
   else
   {
     return NULL;
   }
 }
 
 
 void
 SliceNavigationController::SetRenderer( BaseRenderer *renderer )
 {
   m_Renderer = renderer;
 }
 
 BaseRenderer *
 SliceNavigationController::GetRenderer() const
 {
   return m_Renderer;
 }
 
 
 
 void
 SliceNavigationController::AdjustSliceStepperRange()
 {
   const mitk::SlicedGeometry3D *slicedGeometry =
     dynamic_cast< const mitk::SlicedGeometry3D * >
       ( this->GetCurrentGeometry3D() );
 
   const Vector3D &direction = slicedGeometry->GetDirectionVector();
 
   int c = 0;
   int i, k = 0;
   for ( i = 0; i < 3; ++i )
   {
     if ( fabs(direction[i]) < 0.000000001 ) { ++c; }
     else { k = i; }
   }
 
   if ( c == 2 )
   {
     ScalarType min = slicedGeometry->GetOrigin()[k];
     ScalarType max = min + slicedGeometry->GetExtentInMM( k );
 
     m_Slice->SetRange( min, max );
   }
   else
   {
     m_Slice->InvalidateRange();
   }
 
 }
 
 
 void
 SliceNavigationController::ExecuteOperation( Operation *operation )
 {
   // switch on type
   // - select best slice for a given point
   // - rotate created world geometry according to Operation->SomeInfo()
   if ( !operation )
   {
     return;
   }
 
   switch ( operation->GetOperationType() )
   {
     case OpMOVE: // should be a point operation
     {
       if ( !m_SliceLocked ) //do not move the cross position
       {
         // select a slice
         PointOperation *po = dynamic_cast< PointOperation * >( operation );
         if ( po && po->GetIndex() == -1 )
         {
           this->SelectSliceByPoint( po->GetPoint() );
         }
         else if ( po && po->GetIndex() != -1 ) // undo case because index != -1, index holds the old position of this slice
         {
           this->GetSlice()->SetPos( po->GetIndex() );
         }
       }
       break;
     }
     case OpRESTOREPLANEPOSITION:
       {
         m_CreatedWorldGeometry->ExecuteOperation( operation );
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
     case OpAPPLYTRANSFORMMATRIX:
       {
         m_CreatedWorldGeometry->ExecuteOperation( operation );
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
     default:
     {
       // do nothing
       break;
     }
   }
 }
 
 mitk::DataNode::Pointer SliceNavigationController::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes,mitk::Point3D worldposition)
 {
   mitk::DataNode::Pointer node;
   int  maxlayer = -32768;
   bool isHelper (false);
   if(nodes.IsNotNull())
   {
     for (unsigned int x = 0; x < nodes->size(); x++)
     {
       nodes->at(x)->GetBoolProperty("helper object", isHelper);
       if(nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
       {
         int layer = 0;
         if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
         if(layer > maxlayer)
         {
           if(static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(m_Renderer))
           {
             node = nodes->at(x);
             maxlayer = layer;
           }
         }
       }
     }
   }
   return node;
 }
 // Relict from the old times, when automous decisions were accepted
 // behavior. Remains in here, because some RenderWindows do exist outside
 // of StdMultiWidgets.
 bool
 SliceNavigationController
 ::ExecuteAction( Action* action, StateEvent const* stateEvent )
 {
   bool ok = false;
 
   const PositionEvent* posEvent = dynamic_cast< const PositionEvent * >(
     stateEvent->GetEvent() );
   if ( posEvent != NULL )
   {
     if ( m_CreatedWorldGeometry.IsNull() )
     {
       return true;
     }
     switch (action->GetActionId())
     {
     case AcMOVE:
       {
         BaseRenderer *baseRenderer = posEvent->GetSender();
         if ( !baseRenderer )
         {
           baseRenderer = const_cast<BaseRenderer *>(
             GlobalInteraction::GetInstance()->GetFocus() );
         }
         if ( baseRenderer )
           if ( baseRenderer->GetMapperID() == 1 )
           {
             PointOperation doOp(OpMOVE, posEvent->GetWorldPosition());
 
             this->ExecuteOperation( &doOp );
 
             // If click was performed in this render window than we have to update the status bar information about position and pixel value.
             if(baseRenderer == m_Renderer)
             {
               {
                 std::string statusText;
                 TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
 
                 mitk::DataStorage::SetOfObjects::ConstPointer nodes = baseRenderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
                 mitk::Point3D worldposition = posEvent->GetWorldPosition();
                 //int  maxlayer = -32768;
                 mitk::Image::Pointer image3D;
                 mitk::DataNode::Pointer node;
                 mitk::DataNode::Pointer topSourceNode;
 
                 bool isBinary (false);
 
                 node = this->GetTopLayerNode(nodes,worldposition);
                 if(node.IsNotNull())
                 {
                   node->GetBoolProperty("binary", isBinary);
                   if(isBinary)
                   {
                     mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = baseRenderer->GetDataStorage()->GetSources(node, NULL, true);
                     if(!sourcenodes->empty())
                     {
                       topSourceNode = this->GetTopLayerNode(sourcenodes,worldposition);
                     }
                     if(topSourceNode.IsNotNull())
                     {
                       image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
                     }
                     else
                     {
                       image3D = dynamic_cast<mitk::Image*>(node->GetData());
                     }
                   }
                   else
                   {
                     image3D = dynamic_cast<mitk::Image*>(node->GetData());
                   }
                 }
                 std::stringstream stream;
                 stream.imbue(std::locale::classic());
 
                 // get the position and gray value from the image and build up status bar text
                 if(image3D.IsNotNull())
                 {
                   Index3D p;
                   image3D->GetGeometry()->WorldToIndex(worldposition, p);
                   stream.precision(2);
                   stream<<"Position: <" << std::fixed <<worldposition[0] << ", " << std::fixed << worldposition[1] << ", " << std::fixed << worldposition[2] << "> mm";
                   stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
                   mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
                   if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
                   {
                     stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific<< pixelValue <<"  ";
                   }
                   else
                   {
                     stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<"  ";
                   }
                 }
                 else
                 {
                   stream << "No image information at this position!";
                 }
 
                 statusText = stream.str();
                 mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 
               }
 
             }
             ok = true;
             break;
           }
       }
     default:
       ok = true;
       break;
     }
     return ok;
   }
 
   const DisplayPositionEvent *displPosEvent =
     dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
 
   if ( displPosEvent != NULL )
   {
     return true;
   }
 
   return false;
 }
 
 } // namespace
 
diff --git a/Core/Code/Controllers/mitkSliceNavigationController.h b/Core/Code/Controllers/mitkSliceNavigationController.h
index 2e24d0dcb6..16b740845a 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.h
+++ b/Core/Code/Controllers/mitkSliceNavigationController.h
@@ -1,599 +1,599 @@
 /*===================================================================
 
 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 SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
 #define SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
 
 #include <MitkCoreExports.h>
 #include "mitkBaseController.h"
 #include "mitkRenderingManager.h"
 #include "mitkTimeGeometry.h"
 #include "mitkMessage.h"
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 #include <itkCommand.h>
 #include <sstream>
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkDataStorage.h"
 
 //DEPRECATED
 #include <mitkTimeSlicedGeometry.h>
 
 namespace mitk {
 
 #define mitkTimeSlicedGeometryEventMacro( classname , super ) \
  class MITK_CORE_EXPORT DEPRECATED(classname) : public super { \
    public: \
      typedef classname Self; \
      typedef super Superclass; \
      classname(TimeGeometry* aTimeGeometry, unsigned int aPos) \
      : Superclass(aTimeGeometry, aPos) {} \
      virtual ~classname() {} \
      virtual const char * GetEventName() const { return #classname; } \
      virtual bool CheckEvent(const ::itk::EventObject* e) const \
        { return dynamic_cast<const Self*>(e); } \
      virtual ::itk::EventObject* MakeObject() const \
        { return new Self(GetTimeGeometry(), GetPos()); } \
    private: \
      void operator=(const Self&); \
  }
 
 #define mitkTimeGeometryEventMacro( classname , super ) \
  class MITK_CORE_EXPORT classname : public super { \
    public: \
      typedef classname Self; \
      typedef super Superclass; \
      classname(TimeGeometry* aTimeGeometry, unsigned int aPos) \
      : Superclass(aTimeGeometry, aPos) {} \
      virtual ~classname() {} \
      virtual const char * GetEventName() const { return #classname; } \
      virtual bool CheckEvent(const ::itk::EventObject* e) const \
        { return dynamic_cast<const Self*>(e); } \
      virtual ::itk::EventObject* MakeObject() const \
        { return new Self(GetTimeGeometry(), GetPos()); } \
    private: \
      void operator=(const Self&); \
  }
 
 class PlaneGeometry;
 class BaseGeometry;
 class BaseRenderer;
 
 /**
  * \brief Controls the selection of the slice the associated BaseRenderer
  * will display
  *
- * A SliceNavigationController takes a Geometry3D or a TimeGeometry as input world geometry
+ * A SliceNavigationController takes a BaseGeometry or a TimeGeometry as input world geometry
  * (TODO what are the exact requirements?) and generates a TimeGeometry
  * as output. The TimeGeometry holds a number of SlicedGeometry3Ds and
- * these in turn hold a series of Geometry2Ds. One of these Geometry2Ds is
+ * these in turn hold a series of PlaneGeometries. One of these PlaneGeometries is
  * selected as world geometry for the BaseRenderers associated to 2D views.
  *
  * The SliceNavigationController holds has Steppers (one for the slice, a
  * second for the time step), which control the selection of a single
  * PlaneGeometry from the TimeGeometry. SliceNavigationController generates
  * ITK events to tell observers, like a BaseRenderer,  when the selected slice
  * or timestep changes.
  *
  * SliceNavigationControllers are registered as listeners to GlobalInteraction
  * by the QmitkStdMultiWidget. In ExecuteAction, the controllers react to
  * PositionEvents by setting the steppers to the slice which is nearest to the
  * point of the PositionEvent.
  *
  * Example:
  * \code
  * // Initialization
  * sliceCtrl = mitk::SliceNavigationController::New();
  *
  * // Tell the navigator the geometry to be sliced (with geometry a
- * // Geometry3D::ConstPointer)
+ * // BaseGeometry::ConstPointer)
  * sliceCtrl->SetInputWorldGeometry(geometry.GetPointer());
  *
  * // Tell the navigator in which direction it shall slice the data
  * sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
  *
  * // Connect one or more BaseRenderer to this navigator, i.e.: events sent
  * // by the navigator when stepping through the slices (e.g. by
  * // sliceCtrl->GetSlice()->Next()) will be received by the BaseRenderer
  * // (in this example only slice-changes, see also ConnectGeometryTimeEvent
  * // and ConnectGeometryEvents.)
  * sliceCtrl->ConnectGeometrySliceEvent(renderer.GetPointer());
  *
  * //create a world geometry and send the information to the connected renderer(s)
  * sliceCtrl->Update();
  * \endcode
  *
  *
  * You can connect visible navigators to a SliceNavigationController, e.g., a
  * QmitkSliderNavigator (for Qt):
  *
  * \code
  * // Create the visible navigator (a slider with a spin-box)
  * QmitkSliderNavigator* navigator =
  *   new QmitkSliderNavigator(parent, "slidernavigator");
  *
  * // Connect the navigator to the slice-stepper of the
  * // SliceNavigationController. For initialization (position, mininal and
  * // maximal values) the values of the SliceNavigationController are used.
  * // Thus, accessing methods of a navigator is normally not necessary, since
  * // everything can be set via the (Qt-independent) SliceNavigationController.
  * // The QmitkStepperAdapter converts the Qt-signals to Qt-independent
  * // itk-events.
  * new QmitkStepperAdapter(navigator, sliceCtrl->GetSlice(), "navigatoradaptor");
  * \endcode
  *
  * If you do not want that all renderwindows are updated when a new slice is
  * selected, you can use a specific RenderingManager, which updates only those
  * renderwindows that should be updated. This is sometimes useful when a 3D view
  * does not need to be updated when the slices in some 2D views are changed.
  * QmitkSliderNavigator (for Qt):
  *
  * \code
  * // create a specific RenderingManager
  * mitk::RenderingManager::Pointer myManager = mitk::RenderingManager::New();
  *
  * // tell the RenderingManager to update only renderwindow1 and renderwindow2
  * myManager->AddRenderWindow(renderwindow1);
  * myManager->AddRenderWindow(renderwindow2);
  *
  * // tell the SliceNavigationController of renderwindow1 and renderwindow2
  * // to use the specific RenderingManager instead of the global one
  * renderwindow1->GetSliceNavigationController()->SetRenderingManager(myManager);
  * renderwindow2->GetSliceNavigationController()->SetRenderingManager(myManager);
  * \endcode
  *
  * \todo implement for non-evenly-timed geometry!
  * \ingroup NavigationControl
  */
 class MITK_CORE_EXPORT SliceNavigationController : public BaseController
 {
   public:
     mitkClassMacro(SliceNavigationController,BaseController);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     mitkNewMacro1Param(Self, const char *);
 
     /**
      * \brief Possible view directions, \a Original will uses
      * the PlaneGeometry instances in a SlicedGeometry3D provided
      * as input world geometry (by SetInputWorldGeometry).
      */
     enum ViewDirection
     {
       Axial,
       Sagittal,
       Frontal,
       Original
     };
 
     /**
      * \brief Set the input world geometry3D out of which the
      * geometries for slicing will be created.
      *
      * Any previous previous set input geometry (3D or Time) will
      * be ignored in future.
      */
     void SetInputWorldGeometry3D(const mitk::BaseGeometry* geometry);
     itkGetConstObjectMacro(InputWorldGeometry3D, mitk::BaseGeometry);
 
 
     /**
      * \brief Set the input world geometry3D out of which the
      * geometries for slicing will be created.
      *
      * Any previous previous set input geometry (3D or Time) will
      * be ignored in future.
      * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
      */
     DEPRECATED(void SetInputWorldGeometry(const mitk::TimeSlicedGeometry* geometry));
     /**
      * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
      */
     DEPRECATED(TimeSlicedGeometry* GetInputWorldGeometry());
 
 
     void SetInputWorldTimeGeometry(const mitk::TimeGeometry* geometry);
     itkGetConstObjectMacro(InputWorldTimeGeometry, mitk::TimeGeometry);
 
     /**
      * \brief Access the created geometry
      */
     itkGetConstObjectMacro(CreatedWorldGeometry, mitk::TimeGeometry);
 
     /**
      * \brief Set the desired view directions
      *
      * \sa ViewDirection
      * \sa Update(ViewDirection viewDirection, bool top = true,
      *     bool frontside = true, bool rotated = false)
      */
     itkSetEnumMacro(ViewDirection, ViewDirection);
     itkGetEnumMacro(ViewDirection, ViewDirection);
 
     /**
      * \brief Set the default view direction
      *
      * This is used to re-initialize the view direction of the SNC to the
      * default value with SetViewDirectionToDefault()
      *
      * \sa ViewDirection
      * \sa Update(ViewDirection viewDirection, bool top = true,
      *     bool frontside = true, bool rotated = false)
      */
     itkSetEnumMacro(DefaultViewDirection, ViewDirection);
     itkGetEnumMacro(DefaultViewDirection, ViewDirection);
 
 
     const char* GetViewDirectionAsString();
 
     virtual void SetViewDirectionToDefault();
 
     /**
      * \brief Do the actual creation and send it to the connected
      * observers (renderers)
      *
      */
     virtual void Update();
 
     /**
      * \brief Extended version of Update, additionally allowing to
      * specify the direction/orientation of the created geometry.
      *
      */
     virtual void Update(ViewDirection viewDirection, bool top = true,
       bool frontside = true, bool rotated = false);
 
     /**
      * \brief Send the created geometry to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendCreatedWorldGeometry();
 
     /**
      * \brief Tell observers to re-read the currently selected 2D geometry
      *
      * Called by mitk::SlicesRotator during rotation.
      */
     virtual void SendCreatedWorldGeometryUpdate();
 
     /**
      * \brief Send the currently selected slice to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendSlice();
 
     /**
      * \brief Send the currently selected time to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendTime();
 
     /**
      * \brief Set the RenderingManager to be used
      *
      * If \a NULL, the default RenderingManager will be used.
      */
     itkSetObjectMacro(RenderingManager, RenderingManager);
     mitk::RenderingManager* GetRenderingManager() const;
 
     #pragma GCC visibility push(default)
     itkEventMacro( UpdateEvent, itk::AnyEvent );
     #pragma GCC visibility pop
 
     class MITK_CORE_EXPORT TimeGeometryEvent : public itk::AnyEvent
     {
       public:
         typedef TimeGeometryEvent Self;
         typedef itk::AnyEvent Superclass;
 
         TimeGeometryEvent(
           TimeGeometry* aTimeGeometry, unsigned int aPos)
           : m_TimeGeometry(aTimeGeometry), m_Pos(aPos)
           {}
 
         virtual ~TimeGeometryEvent()
           {}
 
         virtual const char * GetEventName() const
           { return "TimeGeometryEvent"; }
 
         virtual bool CheckEvent(const ::itk::EventObject* e) const
           { return dynamic_cast<const Self*>(e); }
 
         virtual ::itk::EventObject* MakeObject() const
           { return new Self(m_TimeGeometry, m_Pos); }
 
         TimeGeometry* GetTimeGeometry() const
           { return m_TimeGeometry; }
 
         unsigned int GetPos() const
           { return m_Pos; }
 
       private:
         TimeGeometry::Pointer m_TimeGeometry;
         unsigned int m_Pos;
         // TimeGeometryEvent(const Self&);
         void operator=(const Self&); //just hide
     };
 
    /**
    * \deprecatedSince{2013_09} Please use TimeGeometryEvent instead: For additional information see  http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
    */
    DEPRECATED(typedef TimeGeometryEvent TimeSlicedGeometryEvent);
 
     mitkTimeGeometryEventMacro(
       GeometrySendEvent,TimeGeometryEvent );
     mitkTimeGeometryEventMacro(
       GeometryUpdateEvent, TimeGeometryEvent );
     mitkTimeGeometryEventMacro(
       GeometryTimeEvent, TimeGeometryEvent );
     mitkTimeGeometryEventMacro(
       GeometrySliceEvent, TimeGeometryEvent );
 
     template <typename T>
     void ConnectGeometrySendEvent(T* receiver)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer
         ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand =
         itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometry);
       unsigned long tag = AddObserver(GeometrySendEvent(NULL,0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometryUpdateEvent(T* receiver)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer
         ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand =
         itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::UpdateGeometry);
       unsigned long tag = AddObserver(GeometryUpdateEvent(NULL,0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometrySliceEvent(T* receiver, bool connectSendEvent=true)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer
         ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand =
         itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometrySlice);
       unsigned long tag = AddObserver(GeometrySliceEvent(NULL,0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
       if(connectSendEvent)
         ConnectGeometrySendEvent(receiver);
     }
 
     template <typename T>
     void ConnectGeometryTimeEvent(T* receiver, bool connectSendEvent=true)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer
         ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand =
         itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
       unsigned long tag = AddObserver(GeometryTimeEvent(NULL,0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
       if(connectSendEvent)
         ConnectGeometrySendEvent(receiver);
     }
 
     template <typename T>
     void ConnectGeometryEvents(T* receiver)
     {
       //connect sendEvent only once
       ConnectGeometrySliceEvent(receiver, false);
       ConnectGeometryTimeEvent(receiver);
     }
 
     // use a templated method to get the right offset when casting to void*
     template <typename T>
     void Disconnect(T* receiver)
     {
       ObserverTagsMapType::iterator i = m_ReceiverToObserverTagsMap.find(static_cast<void*>(receiver));
       if (i == m_ReceiverToObserverTagsMap.end()) return;
       const std::list<unsigned long>& tags = i->second;
       for (std::list<unsigned long>::const_iterator tagIter = tags.begin();
            tagIter != tags.end(); ++tagIter)
       {
         RemoveObserver(*tagIter);
       }
       m_ReceiverToObserverTagsMap.erase(i);
     }
 
     Message<> crosshairPositionEvent;
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      * \warning not implemented
      */
     virtual void SetGeometry(const itk::EventObject & geometrySliceEvent);
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      */
     virtual void SetGeometrySlice(const itk::EventObject & geometrySliceEvent);
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      */
     virtual void SetGeometryTime(const itk::EventObject & geometryTimeEvent);
 
 
     /** \brief Positions the SNC according to the specified point */
     void SelectSliceByPoint( const mitk::Point3D &point );
 
     /** \brief Returns the TimeGeometry created by the SNC. */
     mitk::TimeGeometry *GetCreatedWorldGeometry();
 
-    /** \brief Returns the Geometry3D of the currently selected time step. */
+    /** \brief Returns the BaseGeometry of the currently selected time step. */
     const mitk::BaseGeometry *GetCurrentGeometry3D();
 
 
     /** \brief Returns the currently selected Plane in the current
-     * Geometry3D (if existent).
+     * BaseGeometry (if existent).
      */
     const mitk::PlaneGeometry *GetCurrentPlaneGeometry();
 
     /** \brief Sets the BaseRenderer associated with this SNC (if any). While
      * the BaseRenderer is not directly used by SNC, this is a convenience
      * method to enable BaseRenderer access via the SNC. */
     void SetRenderer( BaseRenderer *renderer );
 
     /** \brief Gets the BaseRenderer associated with this SNC (if any). While
      * the BaseRenderer is not directly used by SNC, this is a convenience
      * method to enable BaseRenderer access via the SNC. Returns NULL if no
      * BaseRenderer has been specified*/
     BaseRenderer *GetRenderer() const;
 
     /** \brief Re-orients the slice stack. All slices will be oriented to the given normal vector.
          The given point (world coordinates) defines the selected slice.
          Careful: The resulting axis vectors are not clearly defined this way. If you want to define them clearly, use
          ReorientSlices (const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1).
      */
     void ReorientSlices(
       const mitk::Point3D &point, const mitk::Vector3D &normal );
 
 
      /** \brief Re-orients the slice stack so that all planes are oriented according to the
      * given axis vectors. The given Point eventually defines selected slice.
      */
     void ReorientSlices(
        const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1 );
 
 
     virtual bool ExecuteAction(
       Action* action, mitk::StateEvent const* stateEvent);
 
     void ExecuteOperation(Operation* operation);
 
     /**
      * \brief Feature option to lock planes during mouse interaction.
      * This option flag disables the mouse event which causes the center
      * cross to move near by.
      */
     itkSetMacro(SliceLocked, bool);
     itkGetMacro(SliceLocked, bool);
     itkBooleanMacro(SliceLocked);
 
     /**
      * \brief Feature option to lock slice rotation.
      *
      * This option flag disables separately the rotation of a slice which is
      * implemented in mitkSliceRotator.
      */
     itkSetMacro(SliceRotationLocked, bool);
     itkGetMacro(SliceRotationLocked, bool);
     itkBooleanMacro(SliceRotationLocked);
 
     /**
      * \brief Adjusts the numerical range of the slice stepper according to
      * the current geometry orientation of this SNC's SlicedGeometry.
      */
     void AdjustSliceStepperRange();
 
 
   protected:
     SliceNavigationController(const char * type = NULL);
     virtual ~SliceNavigationController();
 
     mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes,mitk::Point3D worldposition);
 /*
     template <class T>
     static void buildstring( mitkIpPicDescriptor *pic, itk::Point<int, 3> p, std::string &s, T = 0)
     {
       std::string value;
       std::stringstream stream;
       stream.imbue(std::locale::classic());
       stream<<s<<"; Pixelvalue: ";
 
       if ( (p[0]>=0 && p[1] >=0 && p[2]>=0) && (unsigned int)p[0] < pic->n[0] && (unsigned int)p[1] < pic->n[1] && (unsigned int)p[2] < pic->n[2] )
       {
         if(pic->bpe!=24)
         {
           stream<<(((T*) pic->data)[ p[0] + p[1]*pic->n[0] + p[2]*pic->n[0]*pic->n[1] ]);
         }
         else
         {
           stream<<(((T*) pic->data)[p[0]*3 + 0 + p[1]*pic->n[0]*3 + p[2]*pic->n[0]*pic->n[1]*3 ]);
           stream<<(((T*) pic->data)[p[0]*3 + 1 + p[1]*pic->n[0]*3 + p[2]*pic->n[0]*pic->n[1]*3 ]);
           stream<<(((T*) pic->data)[p[0]*3 + 2 + p[1]*pic->n[0]*3 + p[2]*pic->n[0]*pic->n[1]*3 ]);
         }
 
         s = stream.str();
       }
       else
       {
         s+= "point out of data";
       }
     };
 */
     mitk::BaseGeometry::ConstPointer m_InputWorldGeometry3D;
     mitk::TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
 
     mitk::TimeGeometry::Pointer m_CreatedWorldGeometry;
 
     ViewDirection m_ViewDirection;
     ViewDirection m_DefaultViewDirection;
 
     mitk::RenderingManager::Pointer m_RenderingManager;
 
     mitk::BaseRenderer *m_Renderer;
 
     itkSetMacro(Top, bool);
     itkGetMacro(Top, bool);
     itkBooleanMacro(Top);
 
     itkSetMacro(FrontSide, bool);
     itkGetMacro(FrontSide, bool);
     itkBooleanMacro(FrontSide);
 
     itkSetMacro(Rotated, bool);
     itkGetMacro(Rotated, bool);
     itkBooleanMacro(Rotated);
 
     bool m_Top;
     bool m_FrontSide;
     bool m_Rotated;
 
     bool m_BlockUpdate;
 
     bool m_SliceLocked;
     bool m_SliceRotationLocked;
     unsigned int m_OldPos;
 
     typedef std::map<void*, std::list<unsigned long> > ObserverTagsMapType;
     ObserverTagsMapType m_ReceiverToObserverTagsMap;
 };
 
 } // namespace mitk
 
 #endif /* SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F */
diff --git a/Core/Code/Controllers/mitkSlicesRotator.cpp b/Core/Code/Controllers/mitkSlicesRotator.cpp
index b773dedc92..280c7bbd1f 100644
--- a/Core/Code/Controllers/mitkSlicesRotator.cpp
+++ b/Core/Code/Controllers/mitkSlicesRotator.cpp
@@ -1,512 +1,512 @@
 /*===================================================================
 
 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 <mitkSlicesRotator.h>
 #include <mitkSliceNavigationController.h>
 
 #include <mitkStateEvent.h>
 #include <mitkAction.h>
 #include <mitkInteractionConst.h>
 #include <mitkDisplayPositionEvent.h>
 #include <mitkRotationOperation.h>
 
 #include <mitkBaseRenderer.h>
 #include <mitkRenderingManager.h>
 
 #include <mitkLine.h>
 #include <mitkGeometry3D.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkDisplayGeometry.h>
 #include <mitkSlicedGeometry3D.h>
 
 #include <vtkLinearTransform.h>
 
 #include <math.h>
 
 #include "rotate_cursor.xpm"
 
 namespace mitk {
 
 SlicesRotator::Pointer SlicesRotator::New()
 {
   return SlicesRotator::New("slices-rotator");
 }
 
 SlicesRotator::SlicesRotator(const char* machine)
 : SlicesCoordinator(machine)
 {
   // make sure that AcSWITCHON and AcSWITCHOFF are defined int constants somewhere (e.g. mitkInteractionConst.h)
   CONNECT_ACTION( AcMOVE, DoSelectSlice );
   CONNECT_ACTION( AcCHECKPOINT, DoDecideBetweenRotationAndSliceSelection );
   CONNECT_ACTION( AcROTATESTART, DoStartRotation );
   CONNECT_ACTION( AcROTATE, DoRotationStep );
   CONNECT_ACTION( AcROTATEEND, DoEndRotation );
 }
 
 SlicesRotator::~SlicesRotator()
 {
 
 }
 
 
 void SlicesRotator::OnSliceControllerAdded(SliceNavigationController* snc)
 {
   if (!snc) return;
 
   snc->ConnectGeometrySendEvent(this); // connects creation of new world geometry to Self::SetGeometry
 }
 
 
 void SlicesRotator::OnSliceControllerRemoved(SliceNavigationController* snc)
 {
   if (!snc) return;
   // nothing to do, base class does the bookkeeping
 }
 
 /// Is called whenever a SliceNavigationController invokes an event. Will update the list
 /// of SliceNavigationControllers that can handle rotation
 void SlicesRotator::SetGeometry(const itk::EventObject& /*EventObject*/)
 {
   // there is no way to determine the sender?
   // ==> update whole list of SNCs
   UpdateRotatableSNCs();
 }
 
 
 void SlicesRotator::RotateToPoint( SliceNavigationController *rotationPlaneSNC,
   SliceNavigationController *rotatedPlaneSNC,
   const Point3D &point, bool linked )
 {
   MITK_WARN << "Deprecated function! Use SliceNavigationController::ReorientSlices() instead";
 
   SliceNavigationController *thirdSNC = NULL;
 
   SNCVector::iterator iter;
   for ( iter = m_RotatableSNCs.begin(); iter != m_RotatableSNCs.end(); ++iter )
   {
     if ( ((*iter) != rotationPlaneSNC)
       && ((*iter) != rotatedPlaneSNC) )
     {
       thirdSNC = *iter;
       break;
     }
   }
 
   if ( thirdSNC == NULL )
   {
     return;
   }
 
   const PlaneGeometry *rotationPlane = rotationPlaneSNC->GetCurrentPlaneGeometry();
   const PlaneGeometry *rotatedPlane = rotatedPlaneSNC->GetCurrentPlaneGeometry();
   const PlaneGeometry *thirdPlane = thirdSNC->GetCurrentPlaneGeometry();
 
   if ( (rotationPlane == NULL) || (rotatedPlane == NULL)
     || (thirdPlane == NULL) )
   {
     return;
   }
 
   if ( rotatedPlane->DistanceFromPlane( point ) < 0.001 )
   {
     // Skip irrelevant rotations
     return;
   }
 
   Point3D projectedPoint;
   Line3D intersection;
   Point3D rotationCenter;
 
   if ( !rotationPlane->Project( point, projectedPoint )
     || !rotationPlane->IntersectionLine( rotatedPlane, intersection )
     || !thirdPlane->IntersectionPoint( intersection, rotationCenter ) )
   {
     return;
   }
 
 
   // All pre-requirements are met; execute the rotation
 
   Point3D referencePoint = intersection.Project( projectedPoint );
 
 
   Vector3D toProjected = referencePoint - rotationCenter;
   Vector3D toCursor    = projectedPoint - rotationCenter;
 
   // cross product: | A x B | = |A| * |B| * sin(angle)
   Vector3D axisOfRotation;
   vnl_vector_fixed< ScalarType, 3 > vnlDirection =
     vnl_cross_3d( toCursor.GetVnlVector(), toProjected.GetVnlVector() );
   axisOfRotation.SetVnlVector( vnlDirection );
 
   // scalar product: A * B = |A| * |B| * cos(angle)
   // tan = sin / cos
   ScalarType angle = - atan2(
     (double)(axisOfRotation.GetNorm()),
     (double)(toCursor * toProjected) );
   angle *= 180.0 / vnl_math::pi;
 
   // create RotationOperation and apply to all SNCs that should be rotated
   RotationOperation op(OpROTATE, rotationCenter, axisOfRotation, angle);
 
   if ( !linked )
   {
     BaseRenderer *renderer = rotatedPlaneSNC->GetRenderer();
     if ( renderer == NULL )
     {
       return;
     }
 
     DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
 
     Point2D point2DWorld, point2DDisplayPre, point2DDisplayPost;
     displayGeometry->Map( rotationCenter, point2DWorld );
     displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPre );
 
     TimeGeometry *timeGeometry= rotatedPlaneSNC->GetCreatedWorldGeometry();
     if ( !timeGeometry )
     {
       return;
     }
 
     timeGeometry->ExecuteOperation( &op );
 
     displayGeometry->Map( rotationCenter, point2DWorld );
     displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPost );
     Vector2D vector2DDisplayDiff = point2DDisplayPost - point2DDisplayPre;
 
     //Vector2D origin = displayGeometry->GetOriginInMM();
 
     displayGeometry->MoveBy( vector2DDisplayDiff );
 
     rotatedPlaneSNC->SendCreatedWorldGeometryUpdate();
   }
   else
   {
     SNCVector::iterator iter;
     for ( iter = m_RotatableSNCs.begin(); iter != m_RotatableSNCs.end(); ++iter )
     {
       BaseRenderer *renderer = (*iter)->GetRenderer();
       if ( renderer == NULL )
       {
         continue;
       }
 
       DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
 
       Point2D point2DWorld, point2DDisplayPre, point2DDisplayPost;
       displayGeometry->Map( rotationCenter, point2DWorld );
       displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPre );
 
       TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
       if ( !timeGeometry )
       {
         continue;
       }
 
       timeGeometry->ExecuteOperation( &op );
 
       displayGeometry->Map( rotationCenter, point2DWorld );
       displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPost );
       Vector2D vector2DDisplayDiff = point2DDisplayPost - point2DDisplayPre;
 
       //Vector2D origin = displayGeometry->GetOriginInMM();
 
       displayGeometry->MoveBy( vector2DDisplayDiff );
 
       (*iter)->SendCreatedWorldGeometryUpdate();
     }
   }
 } // end RotateToPoint
 
 
 /// Updates the list of SliceNavigationControllers that can handle rotation
 void SlicesRotator::UpdateRotatableSNCs()
 {
   m_RotatableSNCs.clear();
 
   for (SNCVector::iterator iter = m_SliceNavigationControllers.begin(); iter != m_SliceNavigationControllers.end(); ++iter)
   {
     const TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
     if (!timeGeometry) continue;
 
     const SlicedGeometry3D* slicedGeometry = dynamic_cast<const SlicedGeometry3D*>( timeGeometry->GetGeometryForTimeStep(0).GetPointer() );
     if (!slicedGeometry) continue;
 
     if (slicedGeometry->IsValidSlice(0))
     {
       // there were some lines of additional checks here in previous versions,
       // all of which would always evaluate to true, so the check was irrelevant.
       // Since the original intent was not documented, I removed all checks,
       // i.e. m_RotatableSNCs ends up being a list of all the registered
       // SliceNavigationControllers which have a SlicedGeometry3D with at least one slice,
       // which covers most standard cases.
       m_RotatableSNCs.push_back( *iter );
     }
   }
 }
 
 bool SlicesRotator::DoSelectSlice(Action* a, const StateEvent* e)
 {
   // just reach through
   for (SNCVector::iterator iter = m_RotatableSNCs.begin(); iter != m_RotatableSNCs.end(); ++iter)
   {
     if ( !(*iter)->GetSliceLocked()  )
     {
       (*iter)->ExecuteAction(a,e);
     }
   }
 
   return true;
 }
 
 bool SlicesRotator::DoDecideBetweenRotationAndSliceSelection(Action*, const StateEvent* e)
 {
   // Decide between moving and rotation slices.
   // For basic decision logic see class documentation.
 
   /*
     Detail logic:
 
      1. Find the SliceNavigationController that has sent the event: this one defines our rendering plane and will NOT be rotated. Must not even be counted or checked..
      2. Inspect every other SliceNavigationController
        - calculate the line intersection of this SliceNavigationController's plane with our rendering plane
        - if there is no interesection, ignore and continue
        - IF there is an intersection
          - check the mouse cursor's distance from that line.
          0. if the line is NOT near the cursor, remember the plane as "one of the other planes" (which can be rotated in "locked" mode)
          1. on first line near the cursor,  just remember this intersection line as THE other plane that we want to rotate
          2. on every consecutive line near the cursor, check if the line is geometrically identical to the line that we want to rotate
             - if yes, we just push this line to the "other" lines and rotate it along
             - if no, then we have a situation where the mouse is near two other lines (e.g. crossing point) and don't want to rotate
   */
   const DisplayPositionEvent* posEvent = dynamic_cast<const DisplayPositionEvent*>(e->GetEvent());
   if (!posEvent) return false;
 
   BaseRenderer* clickedRenderer = e->GetEvent()->GetSender();
-  const PlaneGeometry* ourViewportGeometry = dynamic_cast<const PlaneGeometry*>( clickedRenderer->GetCurrentWorldGeometry2D() );
+  const PlaneGeometry* ourViewportGeometry = dynamic_cast<const PlaneGeometry*>( clickedRenderer->GetCurrentWorldPlaneGeometry() );
   if (!ourViewportGeometry) return false;
 
   DisplayGeometry* clickedDisplayGeometry = clickedRenderer->GetDisplayGeometry();
   if (!clickedDisplayGeometry) return false;
 
   MITK_DEBUG << "=============================================";
   MITK_DEBUG << "Renderer under cursor is " << clickedRenderer->GetName();
 
   Point3D cursorPosition = posEvent->GetWorldPosition();
   const PlaneGeometry* geometryToBeRotated = NULL;  // this one is under the mouse cursor
   const PlaneGeometry* anyOtherGeometry = NULL;    // this is also visible (for calculation of intersection ONLY)
   Line3D intersectionLineWithGeometryToBeRotated;
 
   bool hitMultipleLines(false);
   m_SNCsToBeRotated.clear();
 
   const double threshholdDistancePixels = 12.0;
 
   for (SNCVector::iterator iter = m_RotatableSNCs.begin(); iter != m_RotatableSNCs.end(); ++iter)
   {
      // If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
      if (clickedRenderer->GetMapperID() == BaseRenderer::Standard3D)
         break;
 
     const PlaneGeometry* otherRenderersRenderPlane = (*iter)->GetCurrentPlaneGeometry();
     if (otherRenderersRenderPlane == NULL) continue; // ignore, we don't see a plane
     MITK_DEBUG << "  Checking plane of renderer " << (*iter)->GetRenderer()->GetName();
 
     // check if there is an intersection
     Line3D intersectionLine; // between rendered/clicked geometry and the one being analyzed
     if (!ourViewportGeometry->IntersectionLine( otherRenderersRenderPlane, intersectionLine ))
     {
       continue; // we ignore this plane, it's parallel to our plane
     }
 
     // check distance from intersection line
     double distanceFromIntersectionLine = intersectionLine.Distance( cursorPosition );
     ScalarType distancePixels = distanceFromIntersectionLine / clickedDisplayGeometry->GetScaleFactorMMPerDisplayUnit();
     MITK_DEBUG << "    Distance of plane from cursor " << distanceFromIntersectionLine << " mm, which is around " << distancePixels << " px" ;
 
     // far away line, only remember for linked rotation if necessary
     if (distanceFromIntersectionLine > threshholdDistancePixels)
     {
       MITK_DEBUG << "    Plane is too far away --> remember as otherRenderersRenderPlane";
       anyOtherGeometry = otherRenderersRenderPlane; // we just take the last one, so overwrite each iteration (we just need some crossing point)
                                                    // TODO what about multiple crossings? NOW we have undefined behavior / random crossing point is used
 
       if (m_LinkPlanes)
       {
         m_SNCsToBeRotated.push_back(*iter);
       }
     }
     else // close to cursor
     {
       MITK_DEBUG << "    Plane is close enough to cursor...";
       if ( geometryToBeRotated == NULL ) // first one close to the cursor
       {
         MITK_DEBUG << "    It is the first close enough geometry, remember as geometryToBeRotated";
         geometryToBeRotated = otherRenderersRenderPlane;
         intersectionLineWithGeometryToBeRotated = intersectionLine;
         m_SNCsToBeRotated.push_back(*iter);
       }
       else
       {
         MITK_DEBUG << "    Second or later close enough geometry";
         // compare to the line defined by geometryToBeRotated: if identical, just rotate this otherRenderersRenderPlane together with the primary one
         //                                                     if different, DON'T rotate
 
         if ( intersectionLine.IsParallel( intersectionLineWithGeometryToBeRotated )
           && intersectionLine.Distance( intersectionLineWithGeometryToBeRotated.GetPoint1() ) < mitk::eps )
         {
           MITK_DEBUG << "    This line is the same as intersectionLineWithGeometryToBeRotated which we already know";
           m_SNCsToBeRotated.push_back(*iter);
         }
         else
         {
           MITK_DEBUG << "    This line is NOT the same as intersectionLineWithGeometryToBeRotated which we already know";
           hitMultipleLines = true;
         }
       }
     }
 
   }
 
   bool moveSlices(true);
 
   if ( geometryToBeRotated && anyOtherGeometry && ourViewportGeometry && !hitMultipleLines )
   {
     // assure all three are valid, so calculation of center of rotation can be done
     moveSlices = false;
   }
 
   MITK_DEBUG << "geometryToBeRotated:   " << (void*)geometryToBeRotated;
   MITK_DEBUG << "anyOtherGeometry:    " << (void*)anyOtherGeometry;
   MITK_DEBUG << "ourViewportGeometry: " << (void*)ourViewportGeometry;
   MITK_DEBUG << "hitMultipleLines?    " << hitMultipleLines;
   MITK_DEBUG << "moveSlices?          " << moveSlices;
 
 
   std::auto_ptr<StateEvent> decidedEvent;
 
   // question in state machine is: "rotate?"
   if (moveSlices) // i.e. NOT rotate
   {
     // move all planes to posEvent->GetWorldPosition()
     decidedEvent.reset( new StateEvent(EIDNO, e->GetEvent()) );
       MITK_DEBUG << "Rotation not possible, not enough information (other planes crossing rendering plane) ";
   }
   else
   { // we DO have enough information for rotation
     m_LastCursorPosition = intersectionLineWithGeometryToBeRotated.Project(cursorPosition); // remember where the last cursor position ON THE LINE has been observed
 
     if (anyOtherGeometry->IntersectionPoint(intersectionLineWithGeometryToBeRotated, m_CenterOfRotation)) // find center of rotation by intersection with any of the OTHER lines
     {
       decidedEvent.reset( new StateEvent(EIDYES, e->GetEvent()) );
       MITK_DEBUG << "Rotation possible";
     }
     else
     {
       MITK_DEBUG << "Rotation not possible, cannot determine the center of rotation!?";
       decidedEvent.reset( new StateEvent(EIDNO, e->GetEvent()) );
     }
   }
 
   this->HandleEvent( decidedEvent.get() );
 
   return true;
 }
 
 bool SlicesRotator::DoStartRotation(Action*, const StateEvent*)
 {
   this->SetMouseCursor( rotate_cursor_xpm, 0, 0 );
   this->InvokeEvent( SliceRotationEvent() ); // notify listeners
   return true;
 }
 
 bool SlicesRotator::DoEndRotation(Action*, const StateEvent*)
 {
   this->ResetMouseCursor();
   this->InvokeEvent( SliceRotationEvent() ); // notify listeners
   return true;
 }
 
 
 bool SlicesRotator::DoRotationStep(Action*, const StateEvent* e)
 {
   const DisplayPositionEvent* posEvent = dynamic_cast<const DisplayPositionEvent*>(e->GetEvent());
   if (!posEvent) return false;
 
   Point3D cursor = posEvent->GetWorldPosition();
 
   Vector3D toProjected = m_LastCursorPosition - m_CenterOfRotation;
   Vector3D toCursor    = cursor - m_CenterOfRotation;
 
   // cross product: | A x B | = |A| * |B| * sin(angle)
   Vector3D axisOfRotation;
   vnl_vector_fixed< ScalarType, 3 > vnlDirection = vnl_cross_3d( toCursor.GetVnlVector(), toProjected.GetVnlVector() );
   axisOfRotation.SetVnlVector(vnlDirection);
 
   // scalar product: A * B = |A| * |B| * cos(angle)
   // tan = sin / cos
   ScalarType angle = - atan2( (double)(axisOfRotation.GetNorm()), (double)(toCursor * toProjected) );
   angle *= 180.0 / vnl_math::pi;
   m_LastCursorPosition = cursor;
 
   // create RotationOperation and apply to all SNCs that should be rotated
   RotationOperation rotationOperation(OpROTATE, m_CenterOfRotation, axisOfRotation, angle);
 
   // iterate the OTHER slice navigation controllers: these are filled in DoDecideBetweenRotationAndSliceSelection
   for (SNCVector::iterator iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
   {
     //  - remember the center of rotation on the 2D display BEFORE rotation
     //  - execute rotation
     //  - calculate new center of rotation on 2D display
     //  - move display IF the center of rotation has moved slightly before and after rotation
 
     // DM 2012-10: this must probably be due to rounding errors only, right?
     //             We don't have documentation on if/why this code is needed
     BaseRenderer *renderer = (*iter)->GetRenderer();
     if ( !renderer ) continue;
 
     DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
 
     Point2D rotationCenter2DWorld, point2DDisplayPreRotation, point2DDisplayPostRotation;
     displayGeometry->Map( m_CenterOfRotation, rotationCenter2DWorld );
     displayGeometry->WorldToDisplay( rotationCenter2DWorld, point2DDisplayPreRotation );
 
     TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
     if (!timeGeometry) continue;
 
     timeGeometry->ExecuteOperation(&rotationOperation);
 
     displayGeometry->Map( m_CenterOfRotation, rotationCenter2DWorld );
     displayGeometry->WorldToDisplay( rotationCenter2DWorld, point2DDisplayPostRotation );
     Vector2D vector2DDisplayDiff = point2DDisplayPostRotation - point2DDisplayPreRotation;
 
     displayGeometry->MoveBy( vector2DDisplayDiff );
 
     (*iter)->SendCreatedWorldGeometryUpdate();
   }
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 
   this->InvokeEvent( SliceRotationEvent() ); // notify listeners
 
   return true;
 }
 
 } // namespace
 
diff --git a/Core/Code/Controllers/mitkSlicesRotator.h b/Core/Code/Controllers/mitkSlicesRotator.h
index 7e815e1c70..68d61afea9 100644
--- a/Core/Code/Controllers/mitkSlicesRotator.h
+++ b/Core/Code/Controllers/mitkSlicesRotator.h
@@ -1,165 +1,165 @@
 /*===================================================================
 
 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 SLICESROTATOR_H_HEADER_INCLUDED_C1C55A2F
 #define SLICESROTATOR_H_HEADER_INCLUDED_C1C55A2F
 
 #include <mitkSlicesCoordinator.h>
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 #include <mitkVector.h>
 
 namespace mitk {
 
 /**
   \brief Coordinates rotation of multiple visible rendering planes (represented as lines in other render windows).
   \ingroup NavigationControl
 
   This class takes care of several SliceNavigationControllers and handles slice selection
   / slice rotation. It is added as listener to GlobalInteraction by QmitkStdMultiWidget.
 
   The SlicesRotator class adds the possibility of slice rotation to the "normal" behaviour
   of SliceNavigationControllers (which is picking one plane from a stack of planes).
 
   This additional class SlicesRotator is needed, because one has to be aware of multiple
-  "visible slices" (selected Geometry2Ds of some SliceNavigationControllers) in order to
+  "visible slices" (selected PlaneGeometries of some SliceNavigationControllers) in order to
   choose between rotation and slice selection. Such functionality could not be implemented
   by a single SliceNavigationController.
 
   Rotation is achieved by modifying (rotating) the generated TimeGeometry of the
   corresponding SliceNavigationControllers.
 
   \section mitkSlicesRotator_StandardCase The standard case: three orthogonal views (MPR)
 
   With SlicesRotator, the rule to choose between slice rotation and selection is simple:
   For a mouse down event, count the number of visible planes, which are "near" the cursor.
   If this number is 2 (one for the window, which currently holds the cursor, one for the
   intersection line of another visible slice), then initiate rotation, else select slices
   near the cursor. If the "LinkPlanes" flag is set, the rotation is applied to the planes
   of all registered SNCs, not only of the one associated with the directly selected plane.
 
   In contrast to the situation without the SlicesRotator, the SliceNavigationControllers
   are now NOT directly registered as listeners to GlobalInteraction. SlicesRotator is
   registered as a listener and decides whether something should be rotated or whether
   another slice should be selected. In the latter case, a PositionEvent is just forwarded
   to the SliceNavigationController.
 
   \section mitkSlicesRotator_GeneralizedCase The generalized case: any number of views
 
   Above section as well as the original implementation of this class assumes that we have
   exactly three 2D vies in our scene. This used to be the standard setup of the MITK
   associated application for a long time.  With custom applications based on MITK it is
   easy to create different situations.  One usual use case would be to have one extra
   render window display the contents of any of the other ones and behave exactly like it
   (could e.g. be used on a second screen).
 
   In this situation the above assumption "we rotate when there are exactly 2 slices close
   to the cursor" will not hold: since we always have two render windows displaying the
   exact same slice, the number of 2 is the minimum we get. Whenever the user clicks in one
   of those windows and the cursor is close to one of the orthogonal planes, we will get a
   count of 3 or more planes that are "close to the cursor".
 
   For the class to behave correctly, we actually need to distinguish three separate cases:
    1. the cursor is not close to any orthogonal planes. This should result in slice selection.
    2. the cursor is close to just one orthogonal plane OR multiple which are not distinguishable visually. This should result in rotation.
    3. the cursor is close to multiple orthogonal planes which are rendered as distinguishable lines on the render window. This is the case when we hit the crosshair-center of the view. In this case, we need to also just select slices.
 
    \section mitkSlicesRotator_Solution Deciding between slice selection and rotation
 
    The "counting nearby lines in the renderwindow" can also work for the general case
    described above.  Only one details needs to be accounted for: we must not count a line
    when it is identical to another line. I.e. we just count how many visible lines on the
    screen are very close to the cursor. When this number is 1, we rotate, otherwise we let
    the SliceNavigationControllers do their slice selection job.
 
   \sa SlicesSwiveller
  */
 class MITK_CORE_EXPORT SlicesRotator : public SlicesCoordinator
 {
   public:
 
     mitkClassMacro(SlicesRotator, SlicesCoordinator);
 
     static Pointer New();
 
     /**
       \brief New Macro with one parameter for creating this object with static New(..) method.
 
       Needs to be the "slices-rotator" pattern of StateMachine.xml to work as expected.
      **/
     mitkNewMacro1Param(Self, const char*);
 
     /**
       \brief Callback for modifications in observed SliceNavigationControllers -- forwards to UpdateRotatableSNCs().
 
       This method is called when an observed SliceNavigationController changes its
       world geometry. The connection is established by calling the other SliceNavigationController's
       method ConnectGeometrySendEvent (or similar).
      */
     virtual void SetGeometry(const itk::EventObject& EventObject);
 
     /**
       \brief NOT USED by anything open-source. Deprecated. Highly obfuscated code. Use SliceNavigationController::ReorientSlices() instead!
       #Deprecated
 
      */
     virtual void RotateToPoint( SliceNavigationController *rotationPlaneSNC,
                                 SliceNavigationController *rotatedPlaneSNC,
                                 const Point3D &point,
                                 bool linked = false );
 
   protected:
 
     SlicesRotator(const char* machine);
     virtual ~SlicesRotator();
 
     /**
       \brief Called from SlicesCoordinator after a new controller is added (to internal list m_SliceNavigationControllers).
     */
     virtual void OnSliceControllerAdded(SliceNavigationController* snc);
 
     /*
       \brief Called from SlicesCoordinator after a new controller is being removed (to internal list m_SliceNavigationControllers).
     */
     virtual void OnSliceControllerRemoved(SliceNavigationController* snc);
 
     /**
       \brief Check all observed SliceNavigationControllers: remember those that are rotatable in m_RotatableSNCs.
      */
     virtual void UpdateRotatableSNCs();
 
     // following methods called from superclass ExecuteAction
     bool DoSelectSlice(Action*, const StateEvent*);
     bool DoDecideBetweenRotationAndSliceSelection(Action*, const StateEvent*);
     bool DoStartRotation(Action*, const StateEvent*);
     bool DoEndRotation(Action*, const StateEvent*);
     bool DoRotationStep(Action*, const StateEvent*);
 
     SNCVector m_RotatableSNCs; /// all SNCs that currently have CreatedWorldGeometries, that can be rotated.
     SNCVector m_SNCsToBeRotated; /// all SNCs that will be rotated (exceptions are the ones parallel to the one being clicked)
 
     Point3D  m_LastCursorPosition; /// used for calculation of the rotation angle
     Point3D  m_CenterOfRotation; /// used for calculation of the rotation angle
 
 };
 
 } // namespace
 
 #endif
 
 
diff --git a/Core/Code/Controllers/mitkSlicesSwiveller.cpp b/Core/Code/Controllers/mitkSlicesSwiveller.cpp
index 7dacefebc6..6eea6f8759 100644
--- a/Core/Code/Controllers/mitkSlicesSwiveller.cpp
+++ b/Core/Code/Controllers/mitkSlicesSwiveller.cpp
@@ -1,395 +1,395 @@
 /*===================================================================
 
 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 "mitkSlicesSwiveller.h"
 #include "mitkSliceNavigationController.h"
 
 #include "mitkStateEvent.h"
 #include "mitkAction.h"
 #include "mitkInteractionConst.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkRotationOperation.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkLine.h"
 #include "mitkGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkDisplayGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 #include <math.h>
 
 
 namespace mitk {
 
 SlicesSwiveller::Pointer SlicesSwiveller::New()
 {
   return SlicesSwiveller::New("slices-rotator");
 }
 
 SlicesSwiveller::SlicesSwiveller(const char* machine)
 : SlicesCoordinator(machine),
   m_PreviousRotationAngle( 0.0 )
 {
 }
 
 SlicesSwiveller::~SlicesSwiveller()
 {
 
 }
 
 
 // check if the slices of this SliceNavigationController can be rotated (???) Possible
 void SlicesSwiveller::OnSliceControllerAdded(SliceNavigationController* snc)
 {
   if (!snc) return;
 
   // connects creation of new world geometry to Self::SetGeometry
   snc->ConnectGeometrySendEvent(this);
 }
 
 
 void SlicesSwiveller::OnSliceControllerRemoved(SliceNavigationController* snc)
 {
   if (!snc) return;
   // nothing to do
 }
 
 /// Is called whenever a SliceNavigationController invokes an event. Will
 // update the list of SliceNavigationControllers that can handle rotation
 void SlicesSwiveller::SetGeometry(const itk::EventObject& /*EventObject*/)
 {
   // there is no way to determine the sender?
   // ==> update whole list of SNCs
   UpdateRelevantSNCs();
 }
 
 /// Updates the list of SliceNavigationControllers that can handle rotation
 void SlicesSwiveller::UpdateRelevantSNCs()
 {
   m_RelevantSNCs.clear();
 
   SNCVector::iterator iter;
   for ( iter = m_SliceNavigationControllers.begin();
         iter != m_SliceNavigationControllers.end();
         ++iter)
   {
     const TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
 
     if (!timeGeometry) continue;
 
     const SlicedGeometry3D* slicedGeometry =
       dynamic_cast<const SlicedGeometry3D*>(
         timeGeometry->GetGeometryForTimeStep(0).GetPointer() );
     if (!slicedGeometry) continue;
 
     PlaneGeometry *firstSlice( NULL );
     //PlaneGeometry *secondSlice( NULL );
 
     if (slicedGeometry->IsValidSlice(0))
     {
-      firstSlice = slicedGeometry->GetGeometry2D(0);
+      firstSlice = slicedGeometry->GetPlaneGeometry(0);
     }
 //    if (slicedGeometry->IsValidSlice(1))
 //    {
-//      secondSlice = slicedGeometry->GetGeometry2D(1);
+//      secondSlice = slicedGeometry->GetPlaneGeometry(1);
 //    }
 
     // If the direction vector of these two slices is the same, then accept
     // this slice stack as rotatable
     Vector3D right1 = firstSlice->GetAxisVector(0);
     Vector3D up1 = firstSlice->GetAxisVector(1);
     vnl_vector_fixed< ScalarType, 3 > vnlDirection1 =
       vnl_cross_3d(right1.GetVnlVector(), up1.GetVnlVector());
     Vector3D direction1;
     direction1.SetVnlVector(vnlDirection1);
 
     Vector3D right2 = firstSlice->GetAxisVector(0);
     Vector3D up2 = firstSlice->GetAxisVector(1);
     vnl_vector_fixed< ScalarType, 3 > vnlDirection2 =
       vnl_cross_3d(right2.GetVnlVector(), up2.GetVnlVector());
     Vector3D direction2;
     direction2.SetVnlVector(vnlDirection2);
 
     bool equal = true;
     const ScalarType eps = 0.0001;
     for (int i = 0; i < 3; ++i)
     {
       if ( fabs(direction1[i] - direction2[i]) > eps )
       {
         equal = false;
       }
     }
 
     if (equal) // equal direction vectors
     {
       m_RelevantSNCs.push_back( *iter );
     }
   }
 }
 
 bool SlicesSwiveller
 ::ExecuteAction(Action* action, StateEvent const* stateEvent)
 {
   const ScalarType ThresholdDistancePixels = 6.0;
 
   bool ok = false;
 
   switch ( action->GetActionId() )
   {
     case AcMOVE:
     {
       // just reach through
       SNCVector::iterator iter;
       for ( iter = m_RelevantSNCs.begin();
             iter != m_RelevantSNCs.end();
             ++iter )
       {
         if ( !(*iter)->GetSliceRotationLocked()  )
         {
           (*iter)->ExecuteAction(action, stateEvent);
         }
       }
 
       ok = true;
       break;
     }
     case AcROTATE:
     {
       const DisplayPositionEvent *posEvent =
         dynamic_cast<const DisplayPositionEvent*>(stateEvent->GetEvent());
 
       if (!posEvent) break;
 
       // Determine relative mouse movement projected onto world space
       Point2D cursor = posEvent->GetDisplayPosition();
       Vector2D relativeCursor = cursor - m_ReferenceCursor;
       Vector3D relativeCursorAxis =
         m_RotationPlaneXVector * relativeCursor[0]
         + m_RotationPlaneYVector * relativeCursor[1];
 
       // Determine rotation axis (perpendicular to rotation plane and cursor
       // movement)
       Vector3D rotationAxis = itk::CrossProduct(
         m_RotationPlaneNormal, relativeCursorAxis );
 
       ScalarType rotationAngle = relativeCursor.GetNorm() / 2.0;
 
       // Restore the initial plane pose by undoing the previous rotation
       // operation
       RotationOperation op( OpROTATE, m_CenterOfRotation,
         m_PreviousRotationAxis, -m_PreviousRotationAngle );
 
       SNCVector::iterator iter;
       for ( iter = m_SNCsToBeRotated.begin();
             iter != m_SNCsToBeRotated.end();
             ++iter )
       {
         if ( !(*iter)->GetSliceRotationLocked() )
         {
           TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
           if (!timeGeometry) continue;
 
           timeGeometry->ExecuteOperation(&op);
           (*iter)->SendCreatedWorldGeometryUpdate();
         }
       }
 
       // Apply new rotation operation to all relevant SNCs
       RotationOperation op2( OpROTATE, m_CenterOfRotation,
         rotationAxis, rotationAngle );
 
       for ( iter = m_SNCsToBeRotated.begin();
             iter != m_SNCsToBeRotated.end();
             ++iter)
       {
         if ( !(*iter)->GetSliceRotationLocked() )
         {
           //// Map rotation center onto display geometry (will be used as
           //// pre-rotation vector for compensating a visual shift of the
           //// rotation center)
           //BaseRenderer *renderer = (*iter)->GetRenderer();
           //DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
 
           //Point2D point2DWorld, point2DDisplayPre, point2DDisplayPost;
           //displayGeometry->Map( m_CenterOfRotation, point2DWorld );
           //displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPre );
 
           // Retrieve the TimeGeometry of this SliceNavigationController
           TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
           if (!timeGeometry) continue;
 
           // Execute the new rotation
           timeGeometry->ExecuteOperation(&op2);
 
           //// After rotation: map rotation center onto new display geometry...
           //displayGeometry->Map( m_CenterOfRotation, point2DWorld );
           //displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPost );
           //Vector2D vector2DDisplayDiff = point2DDisplayPost - point2DDisplayPre;
 
           //// And use the difference between pre- and post-rotation vectors to
           //// compensate for display geometry shift:
           //Vector2D origin = displayGeometry->GetOriginInMM();
           //displayGeometry->MoveBy( vector2DDisplayDiff );
 
 
           // Notify listeners
           (*iter)->SendCreatedWorldGeometryUpdate();
         }
       }
 
       m_PreviousRotationAxis = rotationAxis;
       m_PreviousRotationAngle = rotationAngle;
 
 
       RenderingManager::GetInstance()->RequestUpdateAll();
 
       this->InvokeEvent( SliceRotationEvent() ); // notify listeners
 
       ok = true;
       break;
     }
     case AcCHECKPOINT:
     {
       // Decide between moving and rotation: if we're close to the crossing
       // point of the planes, moving mode is entered, otherwise
       // rotation/swivel mode
       const DisplayPositionEvent *posEvent =
         dynamic_cast<const DisplayPositionEvent*>(stateEvent->GetEvent());
 
       BaseRenderer *renderer = stateEvent->GetEvent()->GetSender();
 
       if ( !posEvent || !renderer )
       {
         break;
       }
 
 
       const Point3D &cursor = posEvent->GetWorldPosition();
 
       m_SNCsToBeRotated.clear();
 
       const PlaneGeometry *clickedGeometry( NULL );
       const PlaneGeometry *otherGeometry1( NULL );
       const PlaneGeometry *otherGeometry2( NULL );
 
       SNCVector::iterator iter;
       for ( iter = m_RelevantSNCs.begin(); iter != m_RelevantSNCs.end(); ++iter )
       {
         //unsigned int slice = (*iter)->GetSlice()->GetPos();
         //unsigned int time  = (*iter)->GetTime()->GetPos();
 
         const PlaneGeometry *planeGeometry = (*iter)->GetCurrentPlaneGeometry();
         if ( !planeGeometry ) continue;
 
         if ( *iter == renderer->GetSliceNavigationController() )
         {
           clickedGeometry = planeGeometry;
           m_SNCsToBeRotated.push_back(*iter);
         }
         else
         {
           if ( otherGeometry1 == NULL )
           {
             otherGeometry1 = planeGeometry;
           }
           else
           {
             otherGeometry2 = planeGeometry;
           }
           if ( m_LinkPlanes )
           {
             // If planes are linked, apply rotation to all planes
             m_SNCsToBeRotated.push_back(*iter);
           }
         }
       }
 
       std::auto_ptr<StateEvent> newStateEvent;
 
       mitk::Line3D line;
       mitk::Point3D point;
       if ( (clickedGeometry != NULL) && (otherGeometry1 != NULL)
         && (otherGeometry2 != NULL)
         && clickedGeometry->IntersectionLine( otherGeometry1, line )
         && otherGeometry2->IntersectionPoint( line, point ))
       {
         m_CenterOfRotation = point;
         if ( m_CenterOfRotation.EuclideanDistanceTo( cursor )
            < ThresholdDistancePixels )
         {
           newStateEvent.reset(new StateEvent(EIDNO, stateEvent->GetEvent()));
         }
         else
         {
           m_ReferenceCursor = posEvent->GetDisplayPosition();
 
           // Get main axes of rotation plane and store it for rotation step
           m_RotationPlaneNormal = clickedGeometry->GetNormal();
 
           ScalarType xVector[] = { 1.0, 0.0, 0.0 };
           ScalarType yVector[] = { 0.0, 1.0, 0.0 };
           clickedGeometry->BaseGeometry::IndexToWorld(
             Vector3D( xVector), m_RotationPlaneXVector );
           clickedGeometry->BaseGeometry::IndexToWorld(
             Vector3D( yVector), m_RotationPlaneYVector );
 
           m_RotationPlaneNormal.Normalize();
           m_RotationPlaneXVector.Normalize();
           m_RotationPlaneYVector.Normalize();
 
           m_PreviousRotationAxis.Fill( 0.0 );
           m_PreviousRotationAxis[2] = 1.0;
           m_PreviousRotationAngle = 0.0;
 
           newStateEvent.reset(new StateEvent(EIDYES, stateEvent->GetEvent()));
         }
       }
       else
       {
         newStateEvent.reset(new StateEvent(EIDNO, stateEvent->GetEvent()));
       }
 
       this->HandleEvent( newStateEvent.get() );
 
       ok = true;
       break;
     }
     case AcROTATESTART:
     {
       this->InvokeEvent( SliceRotationEvent() ); // notify listeners
       break;
     }
     case AcROTATEEND:
     {
       this->InvokeEvent( SliceRotationEvent() ); // notify listeners
       break;
     }
     default:
     {
       break;
     }
   }
 
   return ok;
 }
 
 } // namespace
 
diff --git a/Core/Code/Controllers/mitkSlicesSwiveller.h b/Core/Code/Controllers/mitkSlicesSwiveller.h
index e8ab8d8790..def17b0dd7 100644
--- a/Core/Code/Controllers/mitkSlicesSwiveller.h
+++ b/Core/Code/Controllers/mitkSlicesSwiveller.h
@@ -1,119 +1,119 @@
 /*===================================================================
 
 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 SLICESSWIVELLER_H_HEADER_INCLUDED
 #define SLICESSWIVELLER_H_HEADER_INCLUDED
 
 #include <mitkSlicesCoordinator.h>
 #include <mitkVector.h>
 
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 
 namespace mitk {
 
 /**
  * \brief Enables arbitrary rotation of visible slices around a swivel point
  * (for sliced geometries).
  * \ingroup NavigationControl
  *
  * This class takes care of several SliceNavigationControllers and handles
  * slice selection / slice rotation. It is added as listener to
  * GlobalInteraction by QmitkStdMultiWidget.
  *
  * The SlicesSwiveller class adds the possibility of slice rotation to the
  * "normal" behaviour of SliceNavigationControllers. This additional class
  * is needed, because one has to be aware of several "visible slices"
- * (selected Geometry2Ds of some SliceNavigationControllers) in order to
+ * (selected PlaneGeometries of some SliceNavigationControllers) in order to
  * choose between rotation and slice selection.
  *
  * Rotation is achieved by modifying (rotating) the generated
  * TimeGeometry of the corresponding SliceNavigationController.
  *
  * With SlicesSwiveller, slice rotation works as follows: the user clicks onto
  * a 2D view (2D plane) and drags the mouse; the relative direction and angle
  * of the dragged mouse movement directly effects the rotation axis and
  * angle. If "LinkPlanes" is set to true, the rotation is applied to the
  * planes of all registered SNCs, not only of the one associated with the
  * plane clicked on.
  *
  * In contrast to the situation without the SlicesRotator, the
  * SliceNavigationControllers are now not directly registered as listeners to
  * GlobalInteraction. SlicesRotator is registered as a listener and decides
  * whether something should be rotated or whether another slice should be
  * selected. In the latter case, a PositionEvent is just forwarded to the
  * SliceNavigationController.
  *
  * \sa SlicesRotator
  */
 class MITK_CORE_EXPORT SlicesSwiveller : public SlicesCoordinator
 {
 public:
 
   mitkClassMacro(SlicesSwiveller, SlicesCoordinator);
 
   static Pointer New();
   /**
   * @brief New Macro with one parameter for creating this object with static New(..) method
   **/
   mitkNewMacro1Param(Self, const char*);
 
   virtual void SetGeometry(const itk::EventObject& EventObject);
 
 protected:
   SlicesSwiveller(const char* machine);
 
   // clear list of controllers
   virtual ~SlicesSwiveller();
 
   // check if the slices of this SliceNavigationController can be rotated (???) Possible
   virtual void OnSliceControllerAdded(SliceNavigationController* snc);
 
   virtual void OnSliceControllerRemoved(SliceNavigationController* snc);
 
   virtual void UpdateRelevantSNCs();
 
   virtual bool ExecuteAction(Action * action, StateEvent const* stateEvent);
 
 
   /** All SNCs that currently have CreatedWorldGeometries, that can be rotated */
   SNCVector m_RelevantSNCs;
 
   /** SNCs that will be rotated (clicked plane + all relevant others, if linked) */
   SNCVector m_SNCsToBeRotated;
 
   Point3D m_LastCursorPosition;
 
   Point3D m_CenterOfRotation;
 
   Point2D m_ReferenceCursor;
 
   Vector3D m_RotationPlaneNormal;
   Vector3D m_RotationPlaneXVector;
   Vector3D m_RotationPlaneYVector;
 
   Vector3D m_PreviousRotationAxis;
   ScalarType m_PreviousRotationAngle;
 
 };
 
 } // namespace
 
 #endif
 
 
diff --git a/Core/Code/DataManagement/mitkAbstractTransformGeometry.h b/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
index e872adaa27..536a0166b4 100644
--- a/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
+++ b/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
@@ -1,220 +1,218 @@
 /*===================================================================
 
 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 MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 #define MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 
 #include <MitkCoreExports.h>
 #include "mitkPlaneGeometry.h"
 
 #include "itkVtkAbstractTransform.h"
 
 class vtkAbstractTransform;
 
 namespace mitk {
   //##Documentation
   //## @brief Describes a geometry defined by an vtkAbstractTransform and a plane
   //##
   //## vtkAbstractTransform is the most general transform in vtk (superclass for
   //## all vtk geometric transformations). It defines an arbitrary 3D transformation,
   //## i.e., a transformation of 3D space into 3D space. In contrast,
   //## AbstractTransformGeometry (since it is a subclass of PlaneGeometry) describes a
   //## 2D manifold in 3D space. The 2D manifold is defined as the manifold that results
   //## from transforming a rectangle (given in m_Plane as a PlaneGeometry) by the
   //## vtkAbstractTransform (given in m_VtkAbstractTransform).
   //## The PlaneGeometry m_Plane is used to define the parameter space. 2D coordinates are
   //## first mapped by the PlaneGeometry and the resulting 3D coordinates are put into
   //## the vtkAbstractTransform.
   //## @note This class is the superclass of concrete geometries. Since there is no
   //## write access to the vtkAbstractTransform and m_Plane, this class is somehow
   //## abstract. For full write access from extern, use ExternAbstractTransformGeometry.
   //## @note The bounds of the PlaneGeometry are used as the parametric bounds.
   //## @sa ExternAbstractTransformGeometry
   //## @ingroup Geometry
   class MITK_CORE_EXPORT AbstractTransformGeometry : public PlaneGeometry
   {
   public:
     mitkClassMacro(AbstractTransformGeometry, PlaneGeometry);
 
-  itkFactorylessNewMacro(Self)
-  itkCloneMacro(Self)
+    itkFactorylessNewMacro(Self)
+      itkCloneMacro(Self)
 
-    //##Documentation
-    //## @brief Get the vtkAbstractTransform (stored in m_VtkAbstractTransform)
-    virtual vtkAbstractTransform* GetVtkAbstractTransform() const;
+      //##Documentation
+      //## @brief Get the vtkAbstractTransform (stored in m_VtkAbstractTransform)
+      virtual vtkAbstractTransform* GetVtkAbstractTransform() const;
 
     virtual unsigned long GetMTime() const;
 
     //##Documentation
     //## @brief Get the rectangular area that is used for transformation by
     //## m_VtkAbstractTransform and therewith defines the 2D manifold described by
     //## AbstractTransformGeometry
     itkGetConstObjectMacro(Plane, PlaneGeometry);
 
     /**
     * \brief projects the given point onto the curved plane
     */
     virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const;
 
     /**
     * \brief projects a given vector starting from given point onto the curved plane
     * \warning no satisfiyng implementation existing yet
     */
     virtual bool Project(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
 
     /**
     * \brief projects a given vector starting from standard point onto the curved plane
     * \warning no satisfying implementation existing yet
     */
     virtual bool Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
 
     virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
 
     virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
 
     virtual bool Map(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
 
     virtual void Map(const mitk::Point2D & atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
 
     virtual void IndexToWorld(const mitk::Point2D &pt_units, mitk::Point2D &pt_mm) const;
 
     virtual void WorldToIndex(const mitk::Point2D &pt_mm, mitk::Point2D &pt_units) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void IndexToWorld(const mitk::Point2D &atPt2d_units, const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
     virtual bool IsAbove(const Point3D& pt3d_mm) const;
 
     virtual mitk::ScalarType GetParametricExtentInMM(int direction) const;
 
-
     virtual const Transform3D* GetParametricTransform() const;
 
     //##Documentation
     //## @brief Change the parametric bounds to @a oversampling times
     //## the bounds of m_Plane.
     //##
     //## The change is done once (immediately). Later changes of the bounds
     //## of m_Plane will not influence the parametric bounds. (Consequently,
     //## there is no method to get the oversampling.)
     virtual void SetOversampling(mitk::ScalarType oversampling);
 
     //##Documentation
-    //## @brief Calculates the standard part of a Geometry3D
+    //## @brief Calculates the standard part of a BaseGeometry
     //## (IndexToWorldTransform and bounding box) around the
     //## curved geometry. Has to be implemented in subclasses.
     //##
     //## \sa SetFrameGeometry
     virtual void CalculateFrameGeometry();
 
     //##Documentation
     //## @brief Set the frame geometry which is used as the standard
-    //## part of an Geometry3D (IndexToWorldTransform and bounding box)
+    //## part of an BaseGeometry (IndexToWorldTransform and bounding box)
     //##
     //## Maybe used as a hint within which the interpolation shall occur
     //## by concrete sub-classes.
     //## \sa CalculateFrameGeometry
     virtual void SetFrameGeometry(const mitk::BaseGeometry* frameGeometry);
 
     virtual itk::LightObject::Pointer InternalClone() const;
 
-
     //##Documentation
     //## @brief Get the parametric bounding-box
     //##
     //## See AbstractTransformGeometry for an example usage of this.
     itkGetConstObjectMacro(ParametricBoundingBox, BoundingBox);
 
     //##Documentation
     //## @brief Get the parametric bounds
     //##
     //## See AbstractTransformGeometry for an example usage of this.
     const BoundingBox::BoundsArrayType& GetParametricBounds() const;
 
     //##Documentation
     //## @brief Get the parametric extent
     //##
     //## See AbstractTransformGeometry for an example usage of this.
     mitk::ScalarType GetParametricExtent(int direction) const;
 
   protected:
     AbstractTransformGeometry();
     AbstractTransformGeometry(const AbstractTransformGeometry& other);
 
     virtual ~AbstractTransformGeometry();
 
     //##Documentation
     //## @brief Set the vtkAbstractTransform (stored in m_VtkAbstractTransform)
     //##
     //## Protected in this class, made public in ExternAbstractTransformGeometry.
     virtual void SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform);
 
     //##Documentation
     //## @brief Set the rectangular area that is used for transformation by
     //## m_VtkAbstractTransform and therewith defines the 2D manifold described by
     //## ExternAbstractTransformGeometry
     //##
     //## Protected in this class, made public in ExternAbstractTransformGeometry.
     //## @note The bounds of the PlaneGeometry are used as the parametric bounds.
     //## @note The PlaneGeometry is cloned, @em not linked/referenced.
     virtual void SetPlane(const mitk::PlaneGeometry* aPlane);
 
     //##Documentation
     //## @brief The rectangular area that is used for transformation by
     //## m_VtkAbstractTransform and therewith defines the 2D manifold described by
     //## AbstractTransformGeometry.
     mitk::PlaneGeometry::Pointer m_Plane;
 
     itk::VtkAbstractTransform<ScalarType>::Pointer m_ItkVtkAbstractTransform;
 
     mitk::BaseGeometry::Pointer m_FrameGeometry;
 
-    virtual void PostInitialize();
-
-        //##Documentation
+    //##Documentation
     //## @brief Set the parametric bounds
     //##
     //## Protected in this class, made public in some sub-classes, e.g.,
     //## ExternAbstractTransformGeometry.
     virtual void SetParametricBounds(const BoundingBox::BoundsArrayType& bounds);
 
     mutable mitk::BoundingBox::Pointer m_ParametricBoundingBox;
+  private:
+    virtual void PostInitialize();
   };
 } // namespace mitk
 #endif /* MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/mitkBaseData.h b/Core/Code/DataManagement/mitkBaseData.h
index 52abb68cb2..7084c82641 100644
--- a/Core/Code/DataManagement/mitkBaseData.h
+++ b/Core/Code/DataManagement/mitkBaseData.h
@@ -1,429 +1,429 @@
 /*===================================================================
 
 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 BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
 #define BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
 
 #include <itkDataObject.h>
 
 #include "mitkBaseProcess.h"
 #include "mitkTimeGeometry.h"
 #include <MitkCoreExports.h>
 #include "mitkOperationActor.h"
 #include "mitkPropertyList.h"
 
 namespace mitk {
 
 //class BaseProcess;
 
 //##Documentation
 //## @brief Base of all data objects
 //##
 //## Base of all data objects, e.g., images, contours, surfaces etc. Inherits
 //## from itk::DataObject and thus can be included in a pipeline.
 //## Inherits also from OperationActor and can be used as a destination for Undo
 //## @ingroup Data
 class MITK_CORE_EXPORT BaseData : public itk::DataObject, public OperationActor
 {
 public:
   mitkClassMacro(BaseData,itk::DataObject)
 
   /**
   * \brief Return the TimeGeometry of the data as const pointer.
   *
   * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
   * be sure that the geometry is up-to-date.
   *
   * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
   */
   const mitk::TimeGeometry* GetTimeGeometry() const
   {
     return m_TimeGeometry.GetPointer();
   }
 
   /**
   * \brief Return the TimeGeometry of the data as const pointer.
   *
   * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
   * be sure that the geometry is up-to-date.
   *
   * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
    * \deprecatedSince{2013_09} Please use GetTimeGeometry instead: For additional information see  http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
   */
   DEPRECATED(const mitk::TimeGeometry* GetTimeSlicedGeometry() const)
   {
     return GetTimeGeometry();
   }
 
   /**
   * @brief Return the TimeGeometry of the data as pointer.
   *
   * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
   * be sure that the geometry is up-to-date.
   *
   * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
   */
   mitk::TimeGeometry* GetTimeGeometry()
   {
     return m_TimeGeometry.GetPointer();
   }
 
   /**
-  * @brief Return the Geometry3D of the data.
+  * @brief Return the TimeGeometry of the data.
   *
   * The method does not simply return the value of the m_TimeGeometry
   * member. Before doing this, it makes sure that the TimeGeometry
   * is up-to-date (by setting the update extent to largest possible and
   * calling UpdateOutputInformation).
   */
   const mitk::TimeGeometry* GetUpdatedTimeGeometry();
 
   /**
-  * @brief Return the Geometry3D of the data.
+  * @brief Return the TimeGeometry of the data.
   *
   * The method does not simply return the value of the m_TimeGeometry
   * member. Before doing this, it makes sure that the TimeGeometry
   * is up-to-date (by setting the update extent to largest possible and
   * calling UpdateOutputInformation).
   * \deprecatedSince{2013_09} Please use GetUpdatedTimeGeometry instead: For additional information see http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
   */
   DEPRECATED(const mitk::TimeGeometry* GetUpdatedTimeSliceGeometry())
   {
     return GetUpdatedTimeGeometry();
   }
 
   /**
   * \brief Expands the TimeGeometry to a number of TimeSteps.
   *
   * The method expands the TimeGeometry to the given number of TimeSteps,
   * filling newly created elements with empty geometries. Sub-classes should override
   * this method to handle the elongation of their data vectors, too.
   * Note that a shrinking is neither possible nor intended.
   */
   virtual void Expand( unsigned int timeSteps );
 
   /**
-  * \brief Return the Geometry3D of the data at time \a t.
+  * \brief Return the BaseGeometry of the data at time \a t.
   *
   * The method does not simply return
   * m_TimeGeometry->GetGeometry(t).
-  * Before doing this, it makes sure that the Geometry3D is up-to-date
+  * Before doing this, it makes sure that the BaseGeometry is up-to-date
   * (by setting the update extent appropriately and calling
   * UpdateOutputInformation).
   *
   * @todo Appropriate setting of the update extent is missing.
   */
   const mitk::BaseGeometry* GetUpdatedGeometry(int t=0);
 
   //##Documentation
   //## @brief Return the geometry, which is a TimeGeometry, of the data
   //## as non-const pointer.
   //##
   //## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
   //## be sure that the geometry is up-to-date.
   //##
   //## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
   mitk::BaseGeometry* GetGeometry(int t=0) const
   {
     if(m_TimeGeometry.IsNull())
       return NULL;
     return m_TimeGeometry->GetGeometryForTimeStep(t);
   }
 
   //##Documentation
   //## @brief Update the information for this BaseData (the geometry in particular)
   //## so that it can be used as an output of a BaseProcess.
   //##
   //## This method is used in the pipeline mechanism to propagate information and
   //## initialize the meta data associated with a BaseData. Any implementation
   //## of this method in a derived class is assumed to call its source's
   //## BaseProcess::UpdateOutputInformation() which determines modified
   //## times, LargestPossibleRegions, and any extra meta data like spacing,
   //## origin, etc. Default implementation simply call's it's source's
   //## UpdateOutputInformation().
   //## \note Implementations of this methods in derived classes must take care
   //## that the geometry is updated by calling
   //## GetTimeGeometry()->UpdateInformation()
   //## \em after calling its source's BaseProcess::UpdateOutputInformation().
   void UpdateOutputInformation();
 
   //##Documentation
   //## @brief Set the RequestedRegion to the LargestPossibleRegion.
   //##
   //## This forces a filter to produce all of the output in one execution
   //## (i.e. not streaming) on the next call to Update().
   virtual void SetRequestedRegionToLargestPossibleRegion()=0;
 
   //##Documentation
   //## @brief Determine whether the RequestedRegion is outside of the BufferedRegion.
   //##
   //## This method returns true if the RequestedRegion
   //## is outside the BufferedRegion (true if at least one pixel is
   //## outside). This is used by the pipeline mechanism to determine
   //## whether a filter needs to re-execute in order to satisfy the
   //## current request.  If the current RequestedRegion is already
   //## inside the BufferedRegion from the previous execution (and the
   //## current filter is up to date), then a given filter does not need
   //## to re-execute
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion()=0;
 
   //##Documentation
   //## @brief Verify that the RequestedRegion is within the LargestPossibleRegion.
   //##
   //## If the RequestedRegion is not within the LargestPossibleRegion,
   //## then the filter cannot possibly satisfy the request. This method
   //## returns true if the request can be satisfied (even if it will be
   //## necessary to process the entire LargestPossibleRegion) and
   //## returns false otherwise.  This method is used by
   //## PropagateRequestedRegion().  PropagateRequestedRegion() throws a
   //## InvalidRequestedRegionError exception if the requested region is
   //## not within the LargestPossibleRegion.
   virtual bool VerifyRequestedRegion() = 0;
 
   //##Documentation
   //## @brief Copy information from the specified data set.
   //##
   //## This method is part of the pipeline execution model. By default, a
   //## BaseProcess will copy meta-data from the first input to all of its
   //## outputs. See ProcessObject::GenerateOutputInformation().  Each
   //## subclass of DataObject is responsible for being able to copy
   //## whatever meta-data it needs from another DataObject.
   //## The default implementation of this method copies the time sliced geometry
   //## and the property list of an object. If a subclass overrides this
   //## method, it should always call its superclass' version.
   void CopyInformation(const itk::DataObject* data);
 
   //##Documentation
   //## @brief Check whether the data has been initialized, i.e.,
   //## at least the Geometry and other header data has been set
   //##
   //## \warning Set to \a true by default for compatibility reasons.
   //## Set m_Initialized=false in constructors of sub-classes that
   //## support distinction between initialized and uninitialized state.
   virtual bool IsInitialized() const;
 
   //##Documentation
   //## @brief Calls ClearData() and InitializeEmpty();
   //## \warning Only use in subclasses that reimplemented these methods.
   //## Just calling Clear from BaseData will reset an object to a not initialized,
   //## invalid state.
   virtual void Clear();
 
   //##Documentation
   //## @brief Check whether object contains data (at
   //## a specified time), e.g., a set of points may be empty
   //##
   //## \warning Returns IsInitialized()==false by default for
   //## compatibility reasons. Override in sub-classes that
   //## support distinction between empty/non-empty state.
   virtual bool IsEmptyTimeStep(unsigned int t) const;
 
   //##Documentation
   //## @brief Check whether object contains data (at
   //## least at one point in time), e.g., a set of points
   //## may be empty
   //##
   //## \warning Returns IsInitialized()==false by default for
   //## compatibility reasons. Override in sub-classes that
   //## support distinction between empty/non-empty state.
   virtual bool IsEmpty() const;
 
   //##Documentation
   //## @brief Set the requested region from this data object to match the requested
   //## region of the data object passed in as a parameter.
   //##
   //## This method is implemented in the concrete subclasses of BaseData.
   virtual void SetRequestedRegion(const itk::DataObject *data)=0;
 
   //##Documentation
   //##@brief overwrite if the Data can be called by an Interactor (StateMachine).
   //##
   //## Empty by default. Overwrite and implement all the necessary operations here
   //## and get the necessary information from the parameter operation.
   void ExecuteOperation(Operation* operation);
 
   /**
-  * \brief Set the Geometry3D of the data, which will be referenced (not copied!).
+  * \brief Set the BaseGeometry of the data, which will be referenced (not copied!).
   * Assumes the data object has only 1 time step ( is a 3D object ) and creates a
-  * new TimeGeometry which saves the given Geometry3D. If an TimeGeometry has already
+  * new TimeGeometry which saves the given BaseGeometry. If an TimeGeometry has already
   * been set for the object, it will be replaced after calling this function.
   *
   * @warning This method will normally be called internally by the sub-class of BaseData
   * during initialization.
   * \sa SetClonedGeometry
   */
   virtual void SetGeometry(BaseGeometry* aGeometry3D);
 
   /**
   * \brief Set the TimeGeometry of the data, which will be referenced (not copied!).
   *
   * @warning This method will normally be called internally by the sub-class of BaseData
   * during initialization.
   * \sa SetClonedTimeGeometry
   */
   virtual void SetTimeGeometry (TimeGeometry* geometry);
 
   /**
   * \brief Set a clone of the provided TimeGeometry as TimeGeometry of the data.
   * Assumes the data object has only 1 time step ( is a 3D object ) and
   * creates a new TimeGeometry. If an TimeGeometry has already
   * been set for the object, it will be replaced after calling this function.
   *
   * \sa SetGeometry
   */
   virtual void SetClonedGeometry(const BaseGeometry* aGeometry3D);
 
     /**
   * \brief Set a clone of the provided TimeGeometry as TimeGeometry of the data.
   *
   * \sa SetGeometry
   */
   virtual void SetClonedTimeGeometry (const TimeGeometry* geometry);
 
   //##Documentation
-  //## @brief Set a clone of the provided geometry as Geometry3D of a given time step.
+  //## @brief Set a clone of the provided geometry as BaseGeometry of a given time step.
   //##
   //## \sa SetGeometry
   virtual void SetClonedGeometry(const BaseGeometry* aGeometry3D, unsigned int time);
 
   //##Documentation
   //## @brief Get the data's property list
   //## @sa GetProperty
   //## @sa m_PropertyList
   mitk::PropertyList::Pointer GetPropertyList() const;
 
   //##Documentation
   //## @brief Set the data's property list
   //## @sa SetProperty
   //## @sa m_PropertyList
   void SetPropertyList(PropertyList* propertyList);
 
   //##Documentation
   //## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList,
   //## and set it to this, respectively;
   //## @sa GetPropertyList
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   mitk::BaseProperty::Pointer GetProperty(const char *propertyKey) const;
 
   void SetProperty(const char *propertyKey, BaseProperty* property);
 
   //##Documentation
   //## @brief Convenience method for setting the origin of
-  //## the Geometry3D instances of all time steps
+  //## the BaseGeometry instances of all time steps
   //##
-  //## \warning Geometries contained in the Geometry3D will
-  //## \em not be changed, e.g. in case the Geometry3D is a
+  //## \warning Geometries contained in the BaseGeometry will
+  //## \em not be changed, e.g. in case the BaseGeometry is a
   //## SlicedGeometry3D the origin will \em not be propagated
   //## to the contained slices. The sub-class SlicedData
   //## does this for the case that the SlicedGeometry3D is
   //## evenly spaced.
   virtual void SetOrigin(const Point3D& origin);
 
   /** \brief Get the process object that generated this data object.
    *
    * If there is no process object, then the data object has
    * been disconnected from the pipeline, or the data object
    * was created manually. (Note: we cannot use the GetObjectMacro()
    * defined in itkMacro because the mutual dependency of
    * DataObject and ProcessObject causes compile problems. Also,
    * a forward reference smart pointer is returned, not a smart pointer,
    * because of the circular dependency between the process and data object.)
    *
    * GetSource() returns a SmartPointer and not a WeakPointer
    * because it is assumed the code calling GetSource() wants to hold a
    * long term reference to the source. */
   itk::SmartPointer<mitk::BaseDataSource> GetSource() const;
 
   //##Documentation
   //## @brief Get the number of time steps from the TimeGeometry
   //## As the base data has not a data vector given by itself, the number
   //## of time steps is defined over the time sliced geometry. In sub classes,
   //## a better implementation could be over the length of the data vector.
   unsigned int GetTimeSteps() const
   {
     return m_TimeGeometry->CountTimeSteps();
   }
 
 
   //##Documentation
   //## @brief Get the modified time of the last change of the contents
   //## this data object or its geometry.
   virtual unsigned long GetMTime() const;
 
   /**
    * \sa itk::ProcessObject::Graft
    */
   virtual void Graft(const DataObject*);
 
 protected:
   BaseData();
   BaseData(const BaseData &other);
   ~BaseData();
 
   //##Documentation
   //## \brief Initialize the TimeGeometry for a number of time steps.
   //## The TimeGeometry is initialized empty and evenly timed.
   //## In many cases it will be necessary to overwrite this in sub-classes.
   virtual void InitializeTimeGeometry( unsigned int timeSteps = 1 );
 
   /**
   * \brief Initialize the TimeGeometry for a number of time steps.
   * The TimeGeometry is initialized empty and evenly timed.
   * In many cases it will be necessary to overwrite this in sub-classes.
   * \deprecatedSince{2013_09} Please use GetUpdatedTimeGeometry instead: For additional information see http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
   */
   DEPRECATED(virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 ))
   {
     InitializeTimeGeometry(timeSteps);
   }
 
   //##Documentation
   //## @brief reset to non-initialized state, release memory
   virtual void ClearData();
 
   //##Documentation
   //## @brief Pure virtual; Must be used in subclasses to get a data object to a
   //## valid state. Should at least create one empty object and call
   //## Superclass::InitializeTimeGeometry() to ensure an existing valid geometry
   virtual void InitializeEmpty(){}
 
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
   bool m_RequestedRegionInitialized;
   bool m_LastRequestedRegionWasOutsideOfTheBufferedRegion;
 
   mutable unsigned int m_SourceOutputIndexDuplicate;
 
   bool m_Initialized;
 
 private:
 
   //##Documentation
   //## @brief PropertyList, f.e. to hold pic-tags, tracking-data,..
   //##
   PropertyList::Pointer m_PropertyList;
 
   TimeGeometry::Pointer m_TimeGeometry;
 
 };
 
 } // namespace mitk
 
 
 #endif /* BASEDATA_H_HEADER_INCLUDED_C1EBB6FA */
diff --git a/Core/Code/DataManagement/mitkBaseGeometry.cpp b/Core/Code/DataManagement/mitkBaseGeometry.cpp
index 4200af572c..25657c319b 100644
--- a/Core/Code/DataManagement/mitkBaseGeometry.cpp
+++ b/Core/Code/DataManagement/mitkBaseGeometry.cpp
@@ -1,1070 +1,1070 @@
 /*===================================================================
 
 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 <sstream>
 #include <iomanip>
 
 #include "mitkBaseGeometry.h"
 #include "mitkvector.h"
 #include "mitkMatrixConvert.h"
 #include <vtkMatrixToLinearTransform.h>
 #include <vtkMatrix4x4.h>
 #include "mitkRotationOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkApplyTransformMatrixOperation.h"
 #include "mitkPointOperation.h"
 #include "mitkInteractionConst.h"
 
 mitk::BaseGeometry::BaseGeometry(): Superclass(), mitk::OperationActor(),
   m_FrameOfReferenceID(0), m_IndexToWorldTransformLastModified(0), m_ImageGeometry(false)
 {
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   Initialize();
 }
 
 mitk::BaseGeometry::BaseGeometry(const BaseGeometry& other): Superclass(), m_TimeBounds(other.m_TimeBounds),
   m_FrameOfReferenceID(other.m_FrameOfReferenceID), m_IndexToWorldTransformLastModified(other.m_IndexToWorldTransformLastModified), m_Origin(other.m_Origin),
   m_ImageGeometry(other.m_ImageGeometry)
 {
   //  DEPRECATED(m_RotationQuaternion = other.m_RotationQuaternion);
   // AffineGeometryFrame
   SetBounds(other.GetBounds());
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkMatrix->DeepCopy(other.m_VtkMatrix);
 
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->DeepCopy(other.m_VtkIndexToWorldTransform);
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   other.InitializeGeometry(this);
 }
 
 mitk::BaseGeometry::~BaseGeometry()
 {
   m_VtkMatrix->Delete();
   m_VtkIndexToWorldTransform->Delete();
 }
 
 const mitk::Point3D& mitk::BaseGeometry::GetOrigin() const
 {
   return m_Origin;
 }
 
 void mitk::BaseGeometry::SetOrigin(const Point3D & origin)
 {
   if(origin!=GetOrigin())
   {
     m_Origin = origin;
     m_IndexToWorldTransform->SetOffset(m_Origin.GetVectorFromOrigin());
     Modified();
     TransferItkToVtkTransform();
   }
 }
 
 void mitk::BaseGeometry::TransferItkToVtkTransform()
 {
   // copy m_IndexToWorldTransform into m_VtkIndexToWorldTransform
 
   TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix);
   m_VtkIndexToWorldTransform->Modified();
 }
 
 static void CopySpacingFromTransform(mitk::AffineTransform3D* transform, mitk::Vector3D& spacing)
 {
   mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
   vnlmatrix = transform->GetMatrix().GetVnlMatrix();
 
   spacing[0]=vnlmatrix.get_column(0).magnitude();
   spacing[1]=vnlmatrix.get_column(1).magnitude();
   spacing[2]=vnlmatrix.get_column(2).magnitude();
 }
 
 void mitk::BaseGeometry::Initialize()
 {
   float b[6] = {0,1,0,1,0,1};
   SetFloatBounds(b);
 
   if(m_IndexToWorldTransform.IsNull())
     m_IndexToWorldTransform = TransformType::New();
   else
     m_IndexToWorldTransform->SetIdentity();
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
 
   m_VtkMatrix->Identity();
 
   m_TimeBounds[0]=ScalarTypeNumericTraits::NonpositiveMin(); m_TimeBounds[1]=ScalarTypeNumericTraits::max();
 
   m_FrameOfReferenceID = 0;
 
   m_ImageGeometry = false;
 
   this->PostInitialize();
 }
 
 void mitk::BaseGeometry::PostInitializeGeometry(BaseGeometry * newGeometry) const
 {
   newGeometry->m_ImageGeometry = m_ImageGeometry;
 }
 
 void mitk::BaseGeometry::SetFloatBounds(const float bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const float *input = bounds;
   int i=0;
   for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
   SetBounds(b);
 }
 
 void mitk::BaseGeometry::SetFloatBounds(const double bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const double *input = bounds;
   int i=0;
   for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
   SetBounds(b);
 }
 
 /** Initialize the geometry */
 void
   mitk::BaseGeometry::InitializeGeometry(BaseGeometry* newGeometry) const
 {
   newGeometry->SetBounds(m_BoundingBox->GetBounds());
   // we have to create a new transform!!
   newGeometry->SetTimeBounds(m_TimeBounds);
   newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID());
 
   if(m_IndexToWorldTransform)
   {
     TransformType::Pointer indexToWorldTransform = TransformType::New();
     indexToWorldTransform->SetCenter( m_IndexToWorldTransform->GetCenter() );
     indexToWorldTransform->SetMatrix( m_IndexToWorldTransform->GetMatrix() );
     indexToWorldTransform->SetOffset( m_IndexToWorldTransform->GetOffset() );
     newGeometry->SetIndexToWorldTransform(indexToWorldTransform);
   }
 
   this->PostInitializeGeometry(newGeometry);
 }
 void mitk::BaseGeometry::PostInitialize()
 {
 }
 
 /** Set the bounds */
 void mitk::BaseGeometry::SetBounds(const BoundsArrayType& bounds)
 {
   PreSetBounds(bounds);
 
   m_BoundingBox = BoundingBoxType::New();
 
   BoundingBoxType::PointsContainer::Pointer pointscontainer =
     BoundingBoxType::PointsContainer::New();
   BoundingBoxType::PointType p;
   BoundingBoxType::PointIdentifier pointid;
 
   for(pointid=0; pointid<2;++pointid)
   {
     unsigned int i;
     for(i=0; i<m_NDimensions; ++i)
     {
       p[i] = bounds[2*i+pointid];
     }
     pointscontainer->InsertElement(pointid, p);
   }
 
   m_BoundingBox->SetPoints(pointscontainer);
   m_BoundingBox->ComputeBoundingBox();
   this->Modified();
 }
 
 void mitk::BaseGeometry::PreSetBounds(const BoundsArrayType& bounds){};
 
 void mitk::BaseGeometry::SetIndexToWorldTransform(mitk::AffineTransform3D* transform)
 {
   PreSetIndexToWorldTransform(transform);
   if(m_IndexToWorldTransform.GetPointer() != transform)
   {
     m_IndexToWorldTransform = transform;
     CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing);
     vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
     TransferItkToVtkTransform();
     Modified();
   }
   PostSetIndexToWorldTransform(transform);
 }
 
 void mitk::BaseGeometry::PreSetIndexToWorldTransform(mitk::AffineTransform3D* transform)
 {}
 void mitk::BaseGeometry::PostSetIndexToWorldTransform(mitk::AffineTransform3D* transform)
 {}
 
 const  mitk::BaseGeometry::BoundsArrayType  mitk::BaseGeometry::GetBounds() const
 {
   assert(m_BoundingBox.IsNotNull());
   return m_BoundingBox->GetBounds();
 }
 
 bool mitk::BaseGeometry::IsValid() const
 {
   return true;
 }
 
 void mitk::BaseGeometry::SetSpacing(const mitk::Vector3D& aSpacing, bool enforceSetSpacing )
 {
   PreSetSpacing(aSpacing);
   _SetSpacing(aSpacing, enforceSetSpacing);
 }
 
 void mitk::BaseGeometry::PreSetSpacing(const mitk::Vector3D& aSpacing)
 {}
 void mitk::BaseGeometry::_SetSpacing(const mitk::Vector3D& aSpacing, bool enforceSetSpacing){
   if(mitk::Equal(m_Spacing, aSpacing) == false || enforceSetSpacing)
   {
     assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
 
     m_Spacing = aSpacing;
 
     AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
 
     vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
 
     mitk::VnlVector col;
     col = vnlmatrix.get_column(0); col.normalize(); col*=aSpacing[0]; vnlmatrix.set_column(0, col);
     col = vnlmatrix.get_column(1); col.normalize(); col*=aSpacing[1]; vnlmatrix.set_column(1, col);
     col = vnlmatrix.get_column(2); col.normalize(); col*=aSpacing[2]; vnlmatrix.set_column(2, col);
 
     Matrix3D matrix;
     matrix = vnlmatrix;
 
     AffineTransform3D::Pointer transform = AffineTransform3D::New();
     transform->SetMatrix(matrix);
     transform->SetOffset(m_IndexToWorldTransform->GetOffset());
 
     SetIndexToWorldTransform(transform.GetPointer());
   }
 }
 
 mitk::Vector3D mitk::BaseGeometry::GetAxisVector(unsigned int direction) const
 {
   Vector3D frontToBack;
   frontToBack.SetVnlVector(m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction));
   frontToBack *= GetExtent(direction);
   return frontToBack;
 }
 
 mitk::ScalarType mitk::BaseGeometry::GetExtent(unsigned int direction) const
 {
   assert(m_BoundingBox.IsNotNull());
   if (direction>=m_NDimensions)
     mitkThrow() << "Direction is too big. This geometry is for 3D Data";
   BoundsArrayType bounds = m_BoundingBox->GetBounds();
   return bounds[direction*2+1]-bounds[direction*2];
 }
 
 bool mitk::BaseGeometry::Is2DConvertable()
 {
   bool isConvertableWithoutLoss = true;
   do
   {
     if (this->GetSpacing()[2] != 1)
     {
       isConvertableWithoutLoss = false;
       break;
     }
     if (this->GetOrigin()[2] != 0)
     {
       isConvertableWithoutLoss = false;
       break;
     }
     mitk::Vector3D col0, col1, col2;
     col0.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
     col1.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
     col2.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
 
     if ((col0[2] != 0) || (col1[2] != 0) || (col2[0] != 0) || (col2[1] != 0) || (col2[2] != 1))
     {
       isConvertableWithoutLoss = false;
       break;
     }
   } while (0);
 
   return isConvertableWithoutLoss;
 }
 
 mitk::Point3D mitk::BaseGeometry::GetCenter() const
 {
   assert(m_BoundingBox.IsNotNull());
   return m_IndexToWorldTransform->TransformPoint(m_BoundingBox->GetCenter());
 }
 
 double mitk::BaseGeometry::GetDiagonalLength2() const
 {
   Vector3D diagonalvector = GetCornerPoint()-GetCornerPoint(false, false, false);
   return diagonalvector.GetSquaredNorm();
 }
 
 //##Documentation
 //## @brief Get the length of the diagonal of the bounding-box in mm
 //##
 double mitk::BaseGeometry::GetDiagonalLength() const
 {
   return sqrt(GetDiagonalLength2());
 }
 
 mitk::Point3D mitk::BaseGeometry::GetCornerPoint(int id) const
 {
   assert(id >= 0);
   assert(this->IsBoundingBoxNull()==false);
 
   BoundingBox::BoundsArrayType bounds = this->GetBoundingBox()->GetBounds();
 
   Point3D cornerpoint;
   switch(id)
   {
   case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break;
   case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break;
   case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break;
   case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break;
   case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break;
   case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break;
   case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break;
   case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break;
   default:
     {
       itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7.");
     }
   }
   if(m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
   }
   return this->GetIndexToWorldTransform()->TransformPoint(cornerpoint);
 }
 
 mitk::Point3D mitk::BaseGeometry::GetCornerPoint(bool xFront, bool yFront, bool zFront) const
 {
   assert(this->IsBoundingBoxNull()==false);
   BoundingBox::BoundsArrayType bounds = this->GetBoundingBox()->GetBounds();
 
   Point3D cornerpoint;
   cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
   cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
   cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
   if(m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
   }
 
   return this->GetIndexToWorldTransform()->TransformPoint(cornerpoint);
 }
 
 mitk::ScalarType mitk::BaseGeometry::GetExtentInMM(int direction) const
 {
   return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction).magnitude()*GetExtent(direction);
 }
 
 void mitk::BaseGeometry::SetExtentInMM(int direction, ScalarType extentInMM)
 {
   ScalarType len = GetExtentInMM(direction);
   if(fabs(len - extentInMM)>=mitk::eps)
   {
     AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
     if(len>extentInMM)
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)/len*extentInMM);
     else
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)*extentInMM/len);
     Matrix3D matrix;
     matrix = vnlmatrix;
     m_IndexToWorldTransform->SetMatrix(matrix);
     Modified();
   }
   PostSetExtentInMM(direction,extentInMM);
 }
 
 void mitk::BaseGeometry::PostSetExtentInMM(int direction, ScalarType extentInMM){};
 
 bool mitk::BaseGeometry::IsInside(const mitk::Point3D& p) const
 {
   mitk::Point3D index;
   WorldToIndex(p, index);
   return IsIndexInside(index);
 }
 
 bool mitk::BaseGeometry::IsIndexInside(const mitk::Point3D& index) const
 {
   bool inside = false;
   //if it is an image geometry, we need to convert the index to discrete values
   //this is done by applying the rounding function also used in WorldToIndex (see line 323)
   if (m_ImageGeometry)
   {
     mitk::Point3D discretIndex;
     discretIndex[0]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[0] );
     discretIndex[1]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[1] );
     discretIndex[2]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[2] );
 
     inside = this->GetBoundingBox()->IsInside(discretIndex);
     //we have to check if the index is at the upper border of each dimension,
     // because the boundingbox is not centerbased
     if (inside)
     {
       const BoundingBox::BoundsArrayType& bounds = this->GetBoundingBox()->GetBounds();
       if((discretIndex[0] == bounds[1]) ||
         (discretIndex[1] == bounds[3]) ||
         (discretIndex[2] == bounds[5]))
         inside = false;
     }
   }
   else
     inside = this->GetBoundingBox()->IsInside(index);
 
   return inside;
 }
 
 void mitk::BaseGeometry::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const
 {
   BackTransform(pt_mm, pt_units);
 }
 
 void mitk::BaseGeometry::WorldToIndex( const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   BackTransform( vec_mm, vec_units);
 }
 
 void mitk::BaseGeometry::BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const
 {
   // Get WorldToIndex transform
   if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   {
     m_InvertedTransform = TransformType::New();
     if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
     {
       itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
     }
     m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   }
 
   // Check for valid matrix inversion
   const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   if(inverse.GetVnlMatrix().has_nans())
   {
     itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
       << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
       << inverse );
   }
 
   // Transform vector
   for (unsigned int i = 0; i < 3; i++)
   {
     out[i] = 0.0;
     for (unsigned int j = 0; j < 3; j++)
     {
       out[i] += inverse[i][j]*in[j];
     }
   }
 }
 
 void mitk::BaseGeometry::BackTransform(const mitk::Point3D &in, mitk::Point3D& out) const
 {
   ScalarType temp[3];
   unsigned int i, j;
   const TransformType::OffsetType& offset = m_IndexToWorldTransform->GetOffset();
 
   // Remove offset
   for (j = 0; j < 3; j++)
   {
     temp[j] = in[j] - offset[j];
   }
 
   // Get WorldToIndex transform
   if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   {
     m_InvertedTransform = TransformType::New();
     if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
     {
       itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
     }
     m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   }
 
   // Check for valid matrix inversion
   const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   if(inverse.GetVnlMatrix().has_nans())
   {
     itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
       << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
       << inverse );
   }
 
   // Transform point
   for (i = 0; i < 3; i++)
   {
     out[i] = 0.0;
     for (j = 0; j < 3; j++)
     {
       out[i] += inverse[i][j]*temp[j];
     }
   }
 }
 
 mitk::VnlVector mitk::BaseGeometry::GetOriginVnl() const
 {
   return const_cast<Self*>(this)->m_Origin.GetVnlVector();
 }
 
 vtkLinearTransform* mitk::BaseGeometry::GetVtkTransform() const
 {
   return (vtkLinearTransform*)m_VtkIndexToWorldTransform;
 }
 
 void mitk::BaseGeometry::SetIdentity()
 {
   m_IndexToWorldTransform->SetIdentity();
   m_Origin.Fill(0);
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing);
   Modified();
   TransferItkToVtkTransform();
 }
 
 void mitk::BaseGeometry::TransferVtkToItkTransform()
 {
   TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer());
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
 }
 
 void mitk::BaseGeometry::Compose( const mitk::BaseGeometry::TransformType * other, bool pre )
 {
   m_IndexToWorldTransform->Compose(other, pre);
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
   Modified();
   TransferItkToVtkTransform();
 }
 
 void mitk::BaseGeometry::Compose( const vtkMatrix4x4 * vtkmatrix, bool pre )
 {
   mitk::BaseGeometry::TransformType::Pointer itkTransform = mitk::BaseGeometry::TransformType::New();
   TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer());
   Compose(itkTransform, pre);
 }
 
 void mitk::BaseGeometry::Translate(const Vector3D & vector)
 {
   if((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0))
   {
     this->SetOrigin(m_Origin + vector);
   }
 }
 
 void mitk::BaseGeometry::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const
 {
   pt_mm = m_IndexToWorldTransform->TransformPoint(pt_units);
 }
 
 void mitk::BaseGeometry::IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
 }
 
 #include <vtkTransform.h>
 void mitk::BaseGeometry::ExecuteOperation(Operation* operation)
 {
   vtkTransform *vtktransform = vtkTransform::New();
   vtktransform->SetMatrix(m_VtkMatrix);
   switch (operation->GetOperationType())
   {
   case OpNOTHING:
     break;
   case OpMOVE:
     {
       mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
       if (pointOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       mitk::Point3D newPos = pointOp->GetPoint();
       ScalarType data[3];
       vtktransform->GetPosition(data);
       vtktransform->PostMultiply();
       vtktransform->Translate(newPos[0], newPos[1], newPos[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpSCALE:
     {
       mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
       if (pointOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       mitk::Point3D newScale = pointOp->GetPoint();
       ScalarType data[3];
       /* calculate new scale: newscale = oldscale * (oldscale + scaletoadd)/oldscale */
       data[0] = 1 + (newScale[0] / GetMatrixColumn(0).magnitude());
       data[1] = 1 + (newScale[1] / GetMatrixColumn(1).magnitude());
       data[2] = 1 + (newScale[2] / GetMatrixColumn(2).magnitude());
 
       mitk::Point3D center = const_cast<mitk::BoundingBox*>(m_BoundingBox.GetPointer())->GetCenter();
       ScalarType pos[3];
       vtktransform->GetPosition(pos);
       vtktransform->PostMultiply();
       vtktransform->Translate(-pos[0], -pos[1], -pos[2]);
       vtktransform->Translate(-center[0], -center[1], -center[2]);
       vtktransform->PreMultiply();
       vtktransform->Scale(data[0], data[1], data[2]);
       vtktransform->PostMultiply();
       vtktransform->Translate(+center[0], +center[1], +center[2]);
       vtktransform->Translate(pos[0], pos[1], pos[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpROTATE:
     {
       mitk::RotationOperation *rotateOp = dynamic_cast<mitk::RotationOperation *>(operation);
       if (rotateOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       Vector3D rotationVector = rotateOp->GetVectorOfRotation();
       Point3D center = rotateOp->GetCenterOfRotation();
       ScalarType angle = rotateOp->GetAngleOfRotation();
       vtktransform->PostMultiply();
       vtktransform->Translate(-center[0], -center[1], -center[2]);
       vtktransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
       vtktransform->Translate(center[0], center[1], center[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpRESTOREPLANEPOSITION:
     {
       //Copy necessary to avoid vtk warning
       vtkMatrix4x4* matrix = vtkMatrix4x4::New();
       TransferItkTransformToVtkMatrix(dynamic_cast<mitk::RestorePlanePositionOperation*>(operation)->GetTransform().GetPointer(), matrix);
       vtktransform->SetMatrix(matrix);
       break;
     }
   case OpAPPLYTRANSFORMMATRIX:
     {
       ApplyTransformMatrixOperation *applyMatrixOp = dynamic_cast< ApplyTransformMatrixOperation* >( operation );
       vtktransform->SetMatrix(applyMatrixOp->GetMatrix());
       break;
     }
   default:
     vtktransform->Delete();
     return;
   }
   m_VtkMatrix->DeepCopy(vtktransform->GetMatrix());
   TransferVtkToItkTransform();
   Modified();
   vtktransform->Delete();
 }
 
 mitk::VnlVector mitk::BaseGeometry::GetMatrixColumn(unsigned int direction) const
 {
   return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction);
 }
 
 mitk::BoundingBox::Pointer mitk::BaseGeometry::CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const
 {
   mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
 
   mitk::BoundingBox::PointIdentifier pointid=0;
 
   unsigned char i;
   if(transform!=NULL)
   {
     mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
     transform->GetInverse(inverse);
     for(i=0; i<8; ++i)
       pointscontainer->InsertElement( pointid++, inverse->TransformPoint( GetCornerPoint(i) ));
   }
   else
   {
     for(i=0; i<8; ++i)
       pointscontainer->InsertElement( pointid++, GetCornerPoint(i) );
   }
 
   mitk::BoundingBox::Pointer result = mitk::BoundingBox::New();
   result->SetPoints(pointscontainer);
   result->ComputeBoundingBox();
 
   return result;
 }
 
 void mitk::BaseGeometry::SetTimeBounds(const TimeBounds& timebounds)
 {
   if(m_TimeBounds != timebounds)
   {
     m_TimeBounds = timebounds;
     Modified();
   }
   PostSetTimeBounds(timebounds);
 }
 
 void mitk::BaseGeometry::PostSetTimeBounds(const TimeBounds& timebounds)
 {}
 
 const std::string mitk::BaseGeometry::GetTransformAsString( TransformType* transformType )
 {
   std::ostringstream out;
 
   out << '[';
 
   for( int i=0; i<3; ++i )
   {
     out << '[';
     for( int j=0; j<3; ++j )
       out << transformType->GetMatrix().GetVnlMatrix().get(i, j) << ' ';
     out << ']';
   }
 
   out << "][";
 
   for( int i=0; i<3; ++i )
     out << transformType->GetOffset()[i] << ' ';
 
   out << "]\0";
 
   return out.str();
 }
 
 void mitk::BaseGeometry::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix)
 {
   m_VtkMatrix->DeepCopy(vtkmatrix);
   TransferVtkToItkTransform();
 }
 
 void mitk::BaseGeometry::WorldToIndex(const mitk::Point3D & /*atPt3d_mm*/, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function BaseGeometry::WorldToIndex(point, vec, vec). Use BaseGeometry::WorldToIndex(vec, vec) instead!";
   //BackTransform(atPt3d_mm, vec_mm, vec_units);
   this->WorldToIndex(vec_mm, vec_units);
 }
 
 void mitk::BaseGeometry::IndexToWorld(const mitk::Point3D &/*atPt3d_units*/, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function BaseGeometry::IndexToWorld(point, vec, vec). Use BaseGeometry::IndexToWorld(vec, vec) instead!";
   //vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
   this->IndexToWorld(vec_units, vec_mm);
 }
 
 void mitk::BaseGeometry::BackTransform(const mitk::Point3D &/*at*/, const mitk::Vector3D &in, mitk::Vector3D& out) const
 {
   MITK_INFO<<"Warning! Call of the deprecated function BaseGeometry::BackTransform(point, vec, vec). Use BaseGeometry::BackTransform(vec, vec) instead!";
   //// Get WorldToIndex transform
   //if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   //{
   //  m_InvertedTransform = TransformType::New();
   //  if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
   //  {
   //    itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
   //  }
   //  m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   //}
 
   //// Check for valid matrix inversion
   //const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   //if(inverse.GetVnlMatrix().has_nans())
   //{
   //  itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
   //    << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
   //    << inverse );
   //}
 
   //// Transform vector
   //for (unsigned int i = 0; i < 3; i++)
   //{
   //  out[i] = 0.0;
   //  for (unsigned int j = 0; j < 3; j++)
   //  {
   //    out[i] += inverse[i][j]*in[j];
   //  }
   //}
   this->BackTransform(in, out);
 }
 
 vtkMatrix4x4* mitk::BaseGeometry::GetVtkMatrix(){
   return m_VtkMatrix;
 }
 
 bool mitk::BaseGeometry::IsBoundingBoxNull() const{
   return m_BoundingBox.IsNull();
 }
 
 bool mitk::BaseGeometry::IsIndexToWorldTransformNull() const{
   return m_IndexToWorldTransform.IsNull();
 }
 
 void
   mitk::BaseGeometry::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
 {
   // If Geometry is switched to ImageGeometry, you have to put an offset to the origin, because
   // imageGeometries origins are pixel-center-based
   // ... and remove the offset, if you switch an imageGeometry back to a normal geometry
   // For more information please see the Geometry documentation page
 
   if(m_ImageGeometry == isAnImageGeometry)
     return;
 
   const BoundingBox::BoundsArrayType& boundsarray =
     this->GetBoundingBox()->GetBounds();
 
   Point3D  originIndex;
   FillVector3D(originIndex,  boundsarray[0], boundsarray[2], boundsarray[4]);
 
   if(isAnImageGeometry == true)
     FillVector3D( originIndex,
     originIndex[0] + 0.5,
     originIndex[1] + 0.5,
     originIndex[2] + 0.5 );
   else
     FillVector3D( originIndex,
     originIndex[0] - 0.5,
     originIndex[1] - 0.5,
     originIndex[2] - 0.5 );
 
   Point3D originWorld;
 
   originWorld = GetIndexToWorldTransform()
     ->TransformPoint( originIndex );
   // instead could as well call  IndexToWorld(originIndex,originWorld);
 
   SetOrigin(originWorld);
 
   this->SetImageGeometry(isAnImageGeometry);
 }
 //itk::LightObject::Pointer mitk::BaseGeometry::InternalClone() const
 //{
 //  Self::Pointer newGeometry = new Self(*this);
 //  newGeometry->UnRegister();
 //  return newGeometry.GetPointer();
 //}
 
 void mitk::BaseGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " IndexToWorldTransform: ";
   if(this->IsIndexToWorldTransformNull())
     os << "NULL" << std::endl;
   else
   {
     // from itk::MatrixOffsetTransformBase
     unsigned int i, j;
     os << std::endl;
     os << indent << "Matrix: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << this->GetIndexToWorldTransform()->GetMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     os << indent << "Offset: " << this->GetIndexToWorldTransform()->GetOffset() << std::endl;
     os << indent << "Center: " << this->GetIndexToWorldTransform()->GetCenter() << std::endl;
     os << indent << "Translation: " << this->GetIndexToWorldTransform()->GetTranslation() << std::endl;
 
     os << indent << "Inverse: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << this->GetIndexToWorldTransform()->GetInverseMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     // from itk::ScalableAffineTransform
     os << indent << "Scale : ";
     for (i = 0; i < 3; i++)
     {
       os << this->GetIndexToWorldTransform()->GetScale()[i] << " ";
     }
     os << std::endl;
   }
 
   os << indent << " BoundingBox: ";
   if(this->IsBoundingBoxNull())
     os << "NULL" << std::endl;
   else
   {
     os << indent << "( ";
     for (unsigned int i=0; i<3; i++)
     {
       os << this->GetBoundingBox()->GetBounds()[2*i] << "," << this->GetBoundingBox()->GetBounds()[2*i+1] << " ";
     }
     os << " )" << std::endl;
   }
 
   os << indent << " Origin: " << this->GetOrigin() << std::endl;
   os << indent << " ImageGeometry: " << this->GetImageGeometry() << std::endl;
   os << indent << " Spacing: " << this->GetSpacing() << std::endl;
   os << indent << " TimeBounds: " << this->GetTimeBounds() << std::endl;
 }
 
 bool mitk::Equal( const mitk::BaseGeometry::BoundingBoxType *leftHandSide, const mitk::BaseGeometry::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose )
 {
   if(( leftHandSide == NULL) || ( rightHandSide == NULL ))
   {
     MITK_ERROR << "mitk::Equal( const mitk::Geometry3D::BoundingBoxType *leftHandSide, const mitk::Geometry3D::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose ) does not with NULL pointer input.";
     return false;
   }
   return Equal( *leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal( const mitk::BaseGeometry::BoundingBoxType& leftHandSide, const mitk::BaseGeometry::BoundingBoxType& rightHandSide, ScalarType eps, bool verbose )
 {
   bool result = true;
 
-  Geometry3D::BoundsArrayType rightBounds = rightHandSide.GetBounds();
-  Geometry3D::BoundsArrayType leftBounds = leftHandSide.GetBounds();
-  Geometry3D::BoundsArrayType::Iterator itLeft = leftBounds.Begin();
-  for( Geometry3D::BoundsArrayType::Iterator itRight = rightBounds.Begin(); itRight != rightBounds.End(); ++itRight)
+  BaseGeometry::BoundsArrayType rightBounds = rightHandSide.GetBounds();
+  BaseGeometry::BoundsArrayType leftBounds = leftHandSide.GetBounds();
+  BaseGeometry::BoundsArrayType::Iterator itLeft = leftBounds.Begin();
+  for( BaseGeometry::BoundsArrayType::Iterator itRight = rightBounds.Begin(); itRight != rightBounds.End(); ++itRight)
   {
     if(( !mitk::Equal( *itLeft, *itRight, eps )) )
     {
       if(verbose)
       {
         MITK_INFO << "[( Geometry3D::BoundingBoxType )] bounds are not equal.";
         MITK_INFO << "rightHandSide is " << setprecision(12) << *itRight << " : leftHandSide is " << *itLeft << " and tolerance is " << eps;
       }
       result = false;
     }
     itLeft++;
   }
   return result;
 }
 
 bool mitk::Equal(const mitk::BaseGeometry *leftHandSide, const mitk::BaseGeometry *rightHandSide, ScalarType eps, bool verbose)
 {
   if(( leftHandSide == NULL) || ( rightHandSide == NULL ))
   {
     MITK_ERROR << "mitk::Equal(const mitk::Geometry3D *leftHandSide, const mitk::Geometry3D *rightHandSide, ScalarType eps, bool verbose) does not with NULL pointer input.";
     return false;
   }
   return Equal( *leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const mitk::BaseGeometry& leftHandSide, const mitk::BaseGeometry& rightHandSide, ScalarType eps, bool verbose)
 {
   bool result = true;
 
   //Compare spacings
   if( !mitk::Equal( leftHandSide.GetSpacing(), rightHandSide.GetSpacing(), eps ) )
   {
     if(verbose)
     {
       MITK_INFO << "[( Geometry3D )] Spacing differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetSpacing() << " : leftHandSide is " << leftHandSide.GetSpacing() << " and tolerance is " << eps;
     }
     result = false;
   }
 
   //Compare Origins
   if( !mitk::Equal( leftHandSide.GetOrigin(), rightHandSide.GetOrigin(), eps ) )
   {
     if(verbose)
     {
       MITK_INFO << "[( Geometry3D )] Origin differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetOrigin() << " : leftHandSide is " << leftHandSide.GetOrigin() << " and tolerance is " << eps;
     }
     result = false;
   }
 
   //Compare Axis and Extents
   for( unsigned int i=0; i<3; ++i)
   {
     if( !mitk::Equal( leftHandSide.GetAxisVector(i), rightHandSide.GetAxisVector(i), eps))
     {
       if(verbose)
       {
         MITK_INFO << "[( Geometry3D )] AxisVector #" << i << " differ";
         MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetAxisVector(i) << " : leftHandSide is " << leftHandSide.GetAxisVector(i) << " and tolerance is " << eps;
       }
       result =  false;
     }
 
     if( !mitk::Equal( leftHandSide.GetExtent(i), rightHandSide.GetExtent(i), eps) )
     {
       if(verbose)
       {
         MITK_INFO << "[( Geometry3D )] Extent #" << i << " differ";
         MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetExtent(i) << " : leftHandSide is " << leftHandSide.GetExtent(i) << " and tolerance is " << eps;
       }
       result = false;
     }
   }
 
   //Compare ImageGeometry Flag
   if( rightHandSide.GetImageGeometry() != leftHandSide.GetImageGeometry() )
   {
     if(verbose)
     {
       MITK_INFO << "[( Geometry3D )] GetImageGeometry is different.";
       MITK_INFO << "rightHandSide is " << rightHandSide.GetImageGeometry() << " : leftHandSide is " << leftHandSide.GetImageGeometry();
     }
     result = false;
   }
 
   //Compare BoundingBoxes
   if( !mitk::Equal( *leftHandSide.GetBoundingBox(), *rightHandSide.GetBoundingBox(), eps, verbose) )
   {
     result = false;
   }
 
   //Compare IndexToWorldTransform Matrix
   if( !mitk::Equal( *leftHandSide.GetIndexToWorldTransform(), *rightHandSide.GetIndexToWorldTransform(), eps, verbose) )
   {
     result = false;
   }
   return result;
 }
 
 bool mitk::Equal(const BaseGeometry::TransformType *leftHandSide, const BaseGeometry::TransformType *rightHandSide, ScalarType eps, bool verbose )
 {
   if(( leftHandSide == NULL) || ( rightHandSide == NULL ))
   {
     MITK_ERROR << "mitk::Equal(const Geometry3D::TransformType *leftHandSide, const Geometry3D::TransformType *rightHandSide, ScalarType eps, bool verbose ) does not with NULL pointer input.";
     return false;
   }
   return Equal( *leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const BaseGeometry::TransformType& leftHandSide, const BaseGeometry::TransformType& rightHandSide, ScalarType eps, bool verbose )
 {
   //Compare IndexToWorldTransform Matrix
   if( !mitk::MatrixEqualElementWise(  leftHandSide.GetMatrix(),
     rightHandSide.GetMatrix() ) )
   {
     if(verbose)
     {
       MITK_INFO << "[( Geometry3D::TransformType )] Index to World Transformation matrix differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetMatrix() << " : leftHandSide is " << leftHandSide.GetMatrix() << " and tolerance is " << eps;
     }
     return false;
   }
   return true;
 }
diff --git a/Core/Code/DataManagement/mitkBaseGeometry.h b/Core/Code/DataManagement/mitkBaseGeometry.h
index ae4b78a6fd..5598636f70 100644
--- a/Core/Code/DataManagement/mitkBaseGeometry.h
+++ b/Core/Code/DataManagement/mitkBaseGeometry.h
@@ -1,735 +1,738 @@
 /*===================================================================
 
 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 BaseGeometry_H_HEADER_INCLUDED
 #define BaseGeometry_H_HEADER_INCLUDED
 
 #include <MitkCoreExports.h>
 #include <mitkCommon.h>
 #include "mitkoperationactor.h"
 
 #include <itkBoundingBox.h>
 #include "mitkvector.h"
 #include <itkAffineGeometryFrame.h>
 #include <itkQuaternionRigidTransform.h>
 #include "itkScalableAffineTransform.h"
 #include <itkIndex.h>
 
 class vtkMatrix4x4;
 class vtkMatrixToLinearTransform;
 class vtkLinearTransform;
 
 namespace mitk {
   //##Documentation
   //## @brief Standard 3D-BoundingBox typedef
   //##
   //## Standard 3D-BoundingBox typedef to get rid of template arguments (3D, type).
   typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBox;
 
   //##Documentation
   //## @brief Standard typedef for time-bounds
   typedef itk::FixedArray<ScalarType,2>  TimeBounds;
   typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
 
   //##Documentation
   //## @brief BaseGeometry Describes the geometry of a data object
   //##
   //## The class holds
   //## \li a bounding box which is axes-parallel in intrinsic coordinates
   //## (often integer indices of pixels), to be accessed by
   //## GetBoundingBox()
   //## \li a transform to convert intrinsic coordinates into a
   //## world-coordinate system with coordinates in millimeters
   //## and milliseconds (all are floating point values), to
   //## be accessed by GetIndexToWorldTransform()
   //## \li a life span, i.e. a bounding box in time in ms (with
   //## start and end time), to be accessed by GetTimeBounds().
   //## The default is minus infinity to plus infinity.
   //## \li an origin and spacing to define the geometry
   //##
   //## BaseGeometry and its sub-classes allow converting between
   //## intrinsic coordinates (called index or unit coordinates)
   //## and world-coordinates (called world or mm coordinates),
   //## e.g. WorldToIndex.
   //## In case you need integer index coordinates, provide an
   //## mitk::Index3D (or itk::Index) as target variable to
   //## WorldToIndex, otherwise you will get a continuous index
   //## (floating point values).
   //##
   //## An important sub-class is SlicedGeometry3D, which descibes
   //## data objects consisting of slices, e.g., objects of type Image.
   //## Conversions between world coordinates (in mm) and unit coordinates
   //## (e.g., pixels in the case of an Image) can be performed.
   //##
   //## For more information on related classes, see \ref Geometry.
   //##
   //## BaseGeometry instances referring to an Image need a slightly
   //## different definition of corners, see SetImageGeometry. This
   //## is usualy automatically called by Image.
   //##
   //## BaseGeometry have to be initialized in the method GenerateOutputInformation()
   //## of BaseProcess (or CopyInformation/ UpdateOutputInformation of BaseData,
   //## if possible, e.g., by analyzing pic tags in Image) subclasses. See also
   //## itk::ProcessObject::GenerateOutputInformation(),
   //## itk::DataObject::CopyInformation() and
   //## itk::DataObject::UpdateOutputInformation().
   //##
   //## At least, it can return the bounding box of the data object.
   //##
   //## The BaseGeometry class is an abstract class. The most simple implementation
   //## is the sublass Geometry3D.
   //##
   //## Rule: everything is in mm (ms) if not stated otherwise.
   //## @ingroup Geometry
   class MITK_CORE_EXPORT BaseGeometry : public itk::Object, public OperationActor
   {
   public:
     mitkClassMacro(BaseGeometry, itk::Object);
 
-    //##Documentation
-    //## @brief clones the geometry
-    //##
-    //## Overwrite in all sub-classes.
-    //## Normally looks like:
-    //## \code
-    //##  Self::Pointer newGeometry = new Self(*this);
-    //##  newGeometry->UnRegister();
-    //##  return newGeometry.GetPointer();
-    //## \endcode
-    virtual itk::LightObject::Pointer InternalClone() const =0;
-
     // ********************************** TypeDef **********************************
 
     typedef itk::ScalableAffineTransform<ScalarType, 3>    TransformType;
     typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
     typedef BoundingBoxType::BoundsArrayType               BoundsArrayType;
     typedef BoundingBoxType::Pointer                       BoundingBoxPointer;
 
     // ********************************** Origin, Spacing **********************************
 
     //##Documentation
     //## @brief Get the origin, e.g. the upper-left corner of the plane
     const Point3D& GetOrigin() const;
 
     //##Documentation
     //## @brief Set the origin, i.e. the upper-left corner of the plane
     //##
     void SetOrigin(const Point3D& origin);
 
     //##Documentation
     //## @brief Get the spacing (size of a pixel).
     //##
     itkGetConstReferenceMacro(Spacing, mitk::Vector3D);
 
     //##Documentation
     //## @brief Set the spacing (m_Spacing).
     //##
     //##The spacing is also changed in the IndexToWorldTransform.
     void SetSpacing(const mitk::Vector3D& aSpacing, bool enforceSetSpacing = false);
 
     //##Documentation
     //## @brief Get the origin as VnlVector
     //##
     //## \sa GetOrigin
     VnlVector GetOriginVnl() const;
 
     // ********************************** other functions **********************************
 
     //##Documentation
     //## @brief Get the DICOM FrameOfReferenceID referring to the
     //## used world coordinate system
     itkGetConstMacro(FrameOfReferenceID, unsigned int);
     //##Documentation
     //## @brief Set the DICOM FrameOfReferenceID referring to the
     //## used world coordinate system
     itkSetMacro(FrameOfReferenceID, unsigned int);
 
     itkGetConstMacro(IndexToWorldTransformLastModified, unsigned long);
 
     //##Documentation
     //## @brief Is this BaseGeometry in a state that is valid?
     //##
     //## This function returns always true in the BaseGeometry class. Other implementations are possible in subclasses.
     virtual bool IsValid() const;
 
     // ********************************** Initialize **********************************
 
     //##Documentation
     //## @brief Initialize the BaseGeometry
     void Initialize();
 
     void InitializeGeometry(Self * newGeometry) const;
 
     // ********************************** Transformations Set/Get **********************************
 
     // a bit of a misuse, but we want only doxygen to see the following:
 #ifdef DOXYGEN_SKIP
     //##Documentation
     //## @brief Get the transformation used to convert from index
     //## to world coordinates
     itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
 #endif
     //## @brief Set the transformation used to convert from index
     //## to world coordinates. The spacing of the new transform is
     //## copied to m_spacing.
     void SetIndexToWorldTransform(mitk::AffineTransform3D* transform);
 
     //##Documentation
     //## @brief Convenience method for setting the ITK transform
     //## (m_IndexToWorldTransform) via an vtkMatrix4x4.The spacing of
     //## the new transform is copied to m_spacing.
     //## \sa SetIndexToWorldTransform
     virtual void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix);
 
     //## Get the IndexToWorldTransform
     itkGetConstObjectMacro(IndexToWorldTransform, AffineTransform3D);
     itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
 
     //## Get the Vtk Matrix which describes the transform.
     vtkMatrix4x4* GetVtkMatrix();
 
     //##Documentation
     //## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
     vtkLinearTransform* GetVtkTransform() const;
 
     //##Documentation
     //## @brief Set the transform to identity, the spacing to 1 and origin to 0
     //##
     virtual void SetIdentity();
 
     // ********************************** Transformations **********************************
 
     //##Documentation
     //## @brief Compose new IndexToWorldTransform with a given transform.
     //##
     //## This method composes m_IndexToWorldTransform with another transform,
     //## modifying self to be the composition of self and other.
     //## If the argument pre is true, then other is precomposed with self;
     //## that is, the resulting transformation consists of first applying
     //## other to the source, followed by self. If pre is false or omitted,
     //## then other is post-composed with self; that is the resulting
     //## transformation consists of first applying self to the source,
     //## followed by other.
     //## This method also changes m_spacing.
     void Compose( const BaseGeometry::TransformType * other, bool pre = 0 );
 
     //##Documentation
     //## @brief Compose new IndexToWorldTransform with a given vtkMatrix4x4.
     //##
     //## Converts the vtkMatrix4x4 into a itk-transform and calls the previous method.
     void Compose( const vtkMatrix4x4 * vtkmatrix, bool pre = 0 );
 
     //##Documentation
     //## @brief Translate the origin by a vector
     //##
     void Translate(const Vector3D&  vector);
 
     //##Documentation
     //##@brief executes affine operations (translate, rotate, scale)
     virtual void ExecuteOperation(Operation* operation);
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em point to (continuous!) index coordinates
     //## \warning If you need (discrete) integer index coordinates (e.g., for iterating easily over an image),
     //## use WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index).
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Point3D& pt_mm, mitk::Point3D& pt_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em point to (discrete!) index coordinates.
     //## This method rounds to integer indices!
     //## For further information about coordinates types, please see the Geometry documentation
     template <unsigned int VIndexDimension>
     void WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index) const
     {
       typedef itk::Index<VIndexDimension> IndexType;
       mitk::Point3D pt_units;
       this->WorldToIndex(pt_mm, pt_units);
       int i, dim=index.GetIndexDimension();
       if(dim>3)
       {
         index.Fill(0);
         dim=3;
       }
       for(i=0;i<dim;++i){
         index[i]=itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType>( pt_units[i] );
       }
     }
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em point to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Point3D& pt_units, mitk::Point3D& pt_mm) const;
 
     //##Documentation
     //## @brief Convert (discrete) index coordinates of a \em point to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     template <unsigned int VIndexDimension>
     void IndexToWorld(const itk::Index<VIndexDimension> &index, mitk::Point3D& pt_mm ) const
     {
       mitk::Point3D pt_units;
       pt_units.Fill(0);
       int i, dim=index.GetIndexDimension();
       if(dim>3)
       {
         dim=3;
       }
       for(i=0;i<dim;++i)
       {
         pt_units[i] = index[i];
       }
 
       IndexToWorld(pt_units,pt_mm);
     }
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## @deprecated First parameter (Point3D) is not used. If possible, please use void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const.
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Point3D& atPt3d_units, const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## @deprecated First parameter (Point3D) is not used. If possible, please use void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const.
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Point3D& atPt3d_mm, const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
 
     //##Documentation
     //## @brief Deprecated for use with ITK version 3.10 or newer.
     //## Convert ITK physical coordinates of a \em point (in mm,
     //## but without a rotation) into MITK world coordinates (in mm)
     //##
     //## For more information, see WorldToItkPhysicalPoint.
     template<class TCoordRep>
     void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3>& itkPhysicalPoint,
       mitk::Point3D& pt_mm) const
     {
       mitk::vtk2itk(itkPhysicalPoint, pt_mm);
     }
 
     //##Documentation
     //## @brief Deprecated for use with ITK version 3.10 or newer.
     //## Convert world coordinates (in mm) of a \em point to
     //## ITK physical coordinates (in mm, but without a possible rotation)
     //##
     //## This method is useful if you have want to access an mitk::Image
     //## via an itk::Image. ITK v3.8 and older did not support rotated (tilted)
     //## images, i.e., ITK images are always parallel to the coordinate axes.
     //## When accessing a (possibly rotated) mitk::Image via an itk::Image
     //## the rotational part of the transformation in the BaseGeometry is
     //## simply discarded; in other word: only the origin and spacing is
     //## used by ITK, not the complete matrix available in MITK.
     //## With WorldToItkPhysicalPoint you can convert an MITK world
     //## coordinate (including the rotation) into a coordinate that
     //## can be used with the ITK image as a ITK physical coordinate
     //## (excluding the rotation).
     template<class TCoordRep>
     void WorldToItkPhysicalPoint(const mitk::Point3D& pt_mm,
       itk::Point<TCoordRep, 3>& itkPhysicalPoint) const
     {
       mitk::vtk2itk(pt_mm, itkPhysicalPoint);
     }
 
     // ********************************** BoundingBox **********************************
 
     /** Get the bounding box */
     itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
 
     //##Documentation
     //## @brief Get the time bounds (in ms)
     itkGetConstReferenceMacro(TimeBounds, TimeBounds);
 
     // a bit of a misuse, but we want only doxygen to see the following:
 #ifdef DOXYGEN_SKIP
     //##Documentation
     //## @brief Get bounding box (in index/unit coordinates)
     itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
     //##Documentation
     //## @brief Get bounding box (in index/unit coordinates) as a BoundsArrayType
     const BoundsArrayType GetBounds() const;
 #endif
     const BoundsArrayType GetBounds() const;
 
     //##Documentation
     //## \brief Set the bounding box (in index/unit coordinates)
     //##
     //## Only possible via the BoundsArray to make clear that a
     //## copy of the bounding-box is stored, not a reference to it.
     void SetBounds(const BoundsArrayType& bounds);
 
     //##Documentation
     //## @brief Set the bounding box (in index/unit coordinates) via a float array
     void SetFloatBounds(const float bounds[6]);
     //##Documentation
     //## @brief Set the bounding box (in index/unit coordinates) via a double array
     void SetFloatBounds(const double bounds[6]);
 
     //##Documentation
     //## @brief Get a VnlVector along bounding-box in the specified
     //## @a direction, length is spacing
     //##
     //## \sa GetAxisVector
     VnlVector GetMatrixColumn(unsigned int direction) const;
 
     //##Documentation
     //## @brief Calculates a bounding-box around the geometry relative
     //## to a coordinate system defined by a transform
     //##
     mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const;
 
     //##Documentation
     //## @brief Set the time bounds (in ms)
     void SetTimeBounds(const TimeBounds& timebounds);
 
     // ********************************** Geometry **********************************
 
 #ifdef DOXYGEN_SKIP
     //##Documentation
     //## @brief Get the extent of the bounding box (in index/unit coordinates)
     //##
     //## To access the extent in mm use GetExtentInMM
     ScalarType GetExtent(unsigned int direction) const;
 #endif
 
     /** Get the extent of the bounding box */
     ScalarType GetExtent(unsigned int direction) const;
 
     //##Documentation
     //## @brief Get the extent of the bounding-box in the specified @a direction in mm
     //##
     //## Equals length of GetAxisVector(direction).
     ScalarType GetExtentInMM(int direction) const;
 
     //##Documentation
     //## @brief Get vector along bounding-box in the specified @a direction in mm
     //##
     //## The length of the vector is the size of the bounding-box in the
     //## specified @a direction in mm
     //## \sa GetMatrixColumn
     Vector3D GetAxisVector(unsigned int direction) const;
 
     //##Documentation
     //## @brief Checks, if the given geometry can be converted to 2D without information loss
     //## e.g. when a 2D image is saved, the matrix is usually cropped to 2x2, and when you load it back to MITK
     //## it will be filled with standard values. This function checks, if information would be lost during this
     //## procedure
     virtual bool Is2DConvertable();
 
     //##Documentation
     //## @brief Get the center of the bounding-box in mm
     //##
     Point3D GetCenter() const;
 
     //##Documentation
     //## @brief Get the squared length of the diagonal of the bounding-box in mm
     //##
     double GetDiagonalLength2() const;
 
     //##Documentation
     //## @brief Get the length of the diagonal of the bounding-box in mm
     //##
     double GetDiagonalLength() const;
 
     //##Documentation
     //## @brief Get the position of the corner number \a id (in world coordinates)
     //##
     //## See SetImageGeometry for how a corner is defined on images.
     Point3D GetCornerPoint(int id) const;
 
     //##Documentation
     //## @brief Get the position of a corner (in world coordinates)
     //##
     //## See SetImageGeometry for how a corner is defined on images.
     Point3D GetCornerPoint(bool xFront=true, bool yFront=true, bool zFront=true) const;
 
     //##Documentation
     //## @brief Set the extent of the bounding-box in the specified @a direction in mm
     //##
     //## @note This changes the matrix in the transform, @a not the bounds, which are given in units!
     void SetExtentInMM(int direction, ScalarType extentInMM);
 
     //##Documentation
     //## @brief Test whether the point \a p (world coordinates in mm) is
     //## inside the bounding box
     bool IsInside(const mitk::Point3D& p) const;
 
     //##Documentation
     //## @brief Test whether the point \a p ((continous!)index coordinates in units) is
     //## inside the bounding box
     bool IsIndexInside(const mitk::Point3D& index) const;
 
     //##Documentation
     //## @brief Convenience method for working with ITK indices
     template <unsigned int VIndexDimension>
     bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
     {
       int i, dim=index.GetIndexDimension();
       Point3D pt_index;
       pt_index.Fill(0);
       for ( i = 0; i < dim; ++i )
       {
         pt_index[i] = index[i];
       }
       return IsIndexInside(pt_index);
     }
 
     // ********************************* Image Geometry ********************************
     //##Documentation
     //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
     virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
 
     //##Documentation
     //## @brief Is this an ImageGeometry?
     //##
     //## For more information, see SetImageGeometry
     itkGetConstMacro(ImageGeometry, bool);
     //##Documentation
     //## @brief Define that this BaseGeometry is refering to an Image
     //##
     //## A geometry referring to an Image needs a slightly different
     //## definition of the position of the corners (see GetCornerPoint).
     //## The position of a voxel is defined by the position of its center.
     //## If we would use the origin (position of the (center of) the first
     //## voxel) as a corner and display this point, it would seem to be
     //## \em not at the corner but a bit within the image. Even worse for
     //## the opposite corner of the image: here the corner would appear
     //## outside the image (by half of the voxel diameter). Thus, we have
     //## to correct for this and to be able to do that, we need to know
-    //## that the Geometry3D is referring to an Image.
+    //## that the BaseGeometry is referring to an Image.
     itkSetMacro(ImageGeometry, bool);
     itkBooleanMacro(ImageGeometry);
 
   protected:
 
     // ********************************** Constructor **********************************
     BaseGeometry();
     BaseGeometry(const BaseGeometry& other);
     virtual ~BaseGeometry();
 
+    //##Documentation
+    //## @brief clones the geometry
+    //##
+    //## Overwrite in all sub-classes.
+    //## Normally looks like:
+    //## \code
+    //##  Self::Pointer newGeometry = new Self(*this);
+    //##  newGeometry->UnRegister();
+    //##  return newGeometry.GetPointer();
+    //## \endcode
+    virtual itk::LightObject::Pointer InternalClone() const =0;
+
     virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
     void BackTransform(const mitk::Point3D& in, mitk::Point3D& out) const;
 
     //Without redundant parameter Point3D
     void BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
     //##Documentation
     //## @brief Deprecated
     void BackTransform(const mitk::Point3D& at, const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
     //##Documentation
     //## @brief Copy the ITK transform
     //## (m_IndexToWorldTransform) to the VTK transform
     //## \sa SetIndexToWorldTransform
     void TransferItkToVtkTransform();
 
     //##Documentation
     //## @brief Copy the VTK transform
     //## to the ITK transform (m_IndexToWorldTransform)
     //## \sa SetIndexToWorldTransform
     void TransferVtkToItkTransform();
 
     static const std::string GetTransformAsString( TransformType* transformType );
 
+    itkGetConstMacro(NDimensions, unsigned int);
+
+    bool IsBoundingBoxNull() const;
+
+    bool IsIndexToWorldTransformNull() const;
+
+    //##Documentation
+    //## @brief Intern functions to assure a consistent behaviour of SetSpacing.
+    void _SetSpacing(const mitk::Vector3D& aSpacing, bool enforceSetSpacing = false);
+
+  private:
     //##Documentation
     //## @brief Pre- and Post-functions are empty in BaseGeometry
     //##
     //## These virtual functions allow for a different beahiour in subclasses.
     virtual void PreSetBounds(const BoundsArrayType& bounds);
 
     virtual void PostInitialize();
     virtual void PostInitializeGeometry(Self * newGeometry) const;
 
     virtual void PostSetExtentInMM(int direction, ScalarType extentInMM);
 
     virtual void PostSetTimeBounds(const TimeBounds& timebounds);
 
     virtual void PreSetIndexToWorldTransform(mitk::AffineTransform3D* transform);
     virtual void PostSetIndexToWorldTransform(mitk::AffineTransform3D* transform);
 
     virtual void PreSetSpacing(const mitk::Vector3D& aSpacing);
-    void _SetSpacing(const mitk::Vector3D& aSpacing, bool enforceSetSpacing = false);
-
-    itkGetConstMacro(NDimensions, unsigned int);
 
-    bool IsBoundingBoxNull() const;
-
-    bool IsIndexToWorldTransformNull() const;
-
-  private:
     // ********************************** Variables **********************************
     //##Documentation
     //## @brief Spacing, measurement of the resolution
     //##
     mitk::Vector3D m_Spacing;
 
     //##Documentation
     //## @brief Index to World Transform, contains a transformation matrix to convert
     //## points from indes coordinates to world coordinates (mm). The Spacing is included in this variable.
     AffineTransform3D::Pointer m_IndexToWorldTransform;
 
     //##Documentation
     //## @brief Bounding Box, which is axes-parallel in intrinsic coordinates
     //## (often integer indices of pixels)
     BoundingBoxPointer m_BoundingBox;
 
     vtkMatrixToLinearTransform* m_VtkIndexToWorldTransform;
 
     vtkMatrix4x4* m_VtkMatrix;
 
     unsigned int m_FrameOfReferenceID;
 
     mitk::TimeBounds m_TimeBounds;
 
     //##Documentation
     //## @brief Origin, i.e. upper-left corner of the plane
     //##
     Point3D m_Origin;
 
     static const unsigned int m_NDimensions = 3;
 
     mutable TransformType::Pointer m_InvertedTransform;
 
     mutable unsigned long m_IndexToWorldTransformLastModified;
 
     bool m_ImageGeometry;
   };
 
   // ********************************** Equal Functions **********************************
   //
   // Static compare functions mainly for testing
   //
   /**
   * @brief Equal A function comparing two geometries for beeing identical.
-  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::Geometry3D& g1, const mitk::Geometry3D& g2) instead.
+  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::BaseGeometry& g1, const mitk::BaseGeometry& g2) instead.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the spacing, origin, axisvectors, extents, the matrix of the
   * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * If you want to use different tolarance values for different parts of the geometry, feel free to use
   * the other comparison methods and write your own implementation of Equal.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   DEPRECATED( MITK_CORE_EXPORT bool Equal(const mitk::BaseGeometry* leftHandSide, const mitk::BaseGeometry* rightHandSide, ScalarType eps, bool verbose));
 
   /**
   * @brief Equal A function comparing two geometries for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the spacing, origin, axisvectors, extents, the matrix of the
   * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * If you want to use different tolarance values for different parts of the geometry, feel free to use
   * the other comparison methods and write your own implementation of Equal.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITK_CORE_EXPORT bool Equal(const mitk::BaseGeometry& leftHandSide, const mitk::BaseGeometry& rightHandSide, ScalarType eps, bool verbose);
 
   /**
   * @brief Equal A function comparing two transforms (TransformType) for beeing identical.
-  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::Geometry3D::TransformType& t1, const mitk::Geometry3D::TransformType& t2) instead.
+  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::BaseGeometry::TransformType& t1, const mitk::BaseGeometry::TransformType& t2) instead.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the IndexToWorldTransform (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   DEPRECATED( MITK_CORE_EXPORT bool Equal(const mitk::BaseGeometry::TransformType *leftHandSide, const mitk::BaseGeometry::TransformType *rightHandSide, ScalarType eps, bool verbose));
 
   /**
   * @brief Equal A function comparing two transforms (TransformType) for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the IndexToWorldTransform (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITK_CORE_EXPORT bool Equal(const mitk::BaseGeometry::TransformType& leftHandSide, const mitk::BaseGeometry::TransformType& rightHandSide, ScalarType eps, bool verbose);
 
   /**
   * @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
-  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::Geometry3D::BoundingBoxType& b1, const mitk::Geometry3D::BoundingBoxType& b2) instead.
+  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::BaseGeometry::BoundingBoxType& b1, const mitk::BaseGeometry::BoundingBoxType& b2) instead.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the bounds (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   DEPRECATED( MITK_CORE_EXPORT bool Equal( const mitk::BaseGeometry::BoundingBoxType *leftHandSide, const mitk::BaseGeometry::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose));
 
   /**
   * @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the bounds (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITK_CORE_EXPORT bool Equal( const  mitk::BaseGeometry::BoundingBoxType& leftHandSide, const mitk::BaseGeometry::BoundingBoxType& rightHandSide, ScalarType eps, bool verbose);
 } // namespace mitk
 
 #endif /* BaseGeometry_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkGeometry3D.h b/Core/Code/DataManagement/mitkGeometry3D.h
index 9266f9ad84..642c4ce62e 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.h
+++ b/Core/Code/DataManagement/mitkGeometry3D.h
@@ -1,69 +1,69 @@
 /*===================================================================
 
 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 GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 #define GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 
 #include <MitkCoreExports.h>
 #include <mitkCommon.h>
 
 #include "itkScalableAffineTransform.h"
 #include <itkIndex.h>
 
 #include "mitkBaseGeometry.h"
 
 class vtkLinearTransform;
 
 namespace mitk {
   //##Documentation
   //## @brief Standard implementation of BaseGeometry.
   //##
   //## @ingroup Geometry
   class MITK_CORE_EXPORT Geometry3D : public BaseGeometry
   {
   public:
     mitkClassMacro(Geometry3D, mitk::BaseGeometry);
 
     typedef itk::QuaternionRigidTransform< ScalarType > QuaternionTransformType;
     typedef QuaternionTransformType::VnlQuaternionType VnlQuaternionType;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
       mitkNewMacro1Param(Self,Self);
 
     itkCloneMacro(Self)
 
-      //##Documentation
-      //## @brief clones the geometry
-      //##
-      //## Overwrite in all sub-classes.
-      //## Normally looks like:
-      //## \code
-      //##  Self::Pointer newGeometry = new Self(*this);
-      //##  newGeometry->UnRegister();
-      //##  return newGeometry.GetPointer();
-      //## \endcode
-      virtual itk::LightObject::Pointer InternalClone() const;
-
   protected:
     Geometry3D();
     Geometry3D(const Geometry3D& other);
 
+    //##Documentation
+    //## @brief clones the geometry
+    //##
+    //## Overwrite in all sub-classes.
+    //## Normally looks like:
+    //## \code
+    //##  Self::Pointer newGeometry = new Self(*this);
+    //##  newGeometry->UnRegister();
+    //##  return newGeometry.GetPointer();
+    //## \endcode
+    virtual itk::LightObject::Pointer InternalClone() const;
+
     virtual ~Geometry3D();
   };
 } // namespace mitk
 
 #endif /* GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkGeometryData.h b/Core/Code/DataManagement/mitkGeometryData.h
index 5dc905f072..0bb41c588f 100644
--- a/Core/Code/DataManagement/mitkGeometryData.h
+++ b/Core/Code/DataManagement/mitkGeometryData.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 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 MITKGEOMETRYDATA_H_HEADER_INCLUDED_C19C01E2
 #define MITKGEOMETRYDATA_H_HEADER_INCLUDED_C19C01E2
 
 #include "mitkBaseData.h"
 
 namespace mitk {
 
 //##Documentation
-//## @brief Data class only having a Geometry3D but not containing
+//## @brief Data class only having a BaseGeometry but not containing
 //## any specific data.
 //##
 //## Only implements pipeline methods which are abstract in BaseData.
 //## @ingroup Geometry
 class MITK_CORE_EXPORT GeometryData : public BaseData
 {
 public:
   mitkClassMacro(GeometryData, BaseData);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   virtual void UpdateOutputInformation();
 
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   virtual bool VerifyRequestedRegion();
 
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
   virtual void CopyInformation(const itk::DataObject *data);
 
 protected:
   GeometryData();
 
   virtual ~GeometryData();
 };
 
 } // namespace mitk
 #endif /* MITKGEOMETRYDATA_H_HEADER_INCLUDED_C19C01E2 */
diff --git a/Core/Code/DataManagement/mitkImage.cpp b/Core/Code/DataManagement/mitkImage.cpp
index a7a10c1487..5761913f8a 100644
--- a/Core/Code/DataManagement/mitkImage.cpp
+++ b/Core/Code/DataManagement/mitkImage.cpp
@@ -1,1383 +1,1383 @@
 /*===================================================================
 
 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 "mitkImage.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkPixelTypeMultiplex.h"
 #include <mitkProportionalTimeGeometry.h>
 #include "mitkCompareImageDataFilter.h"
 
 //VTK
 #include <vtkImageData.h>
 
 //Other
 #include <cmath>
 
 #define FILL_C_ARRAY( _arr, _size, _value) for(unsigned int i=0u; i<_size; i++) \
 { _arr[i] = _value; }
 
 
 mitk::Image::Image() :
   m_Dimension(0), m_Dimensions(NULL), m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL),
   m_ImageStatistics(NULL)
 {
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
   FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
 
   m_Initialized = false;
 }
 
 mitk::Image::Image(const Image &other) : SlicedData(other), m_Dimension(0), m_Dimensions(NULL),
   m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL), m_ImageStatistics(NULL)
 {
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
   FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
 
   this->Initialize( other.GetPixelType(), other.GetDimension(), other.GetDimensions());
 
   //Since the above called "Initialize" method doesn't take the geometry into account we need to set it
   //here manually
   TimeGeometry::Pointer cloned = other.GetTimeGeometry()->Clone();
   this->SetTimeGeometry(cloned.GetPointer());
 
   if (this->GetDimension() > 3)
   {
     const unsigned int time_steps = this->GetDimension(3);
 
     for (unsigned int i = 0u; i < time_steps; ++i)
     {
       ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(i);
 
       this->SetVolume(volume->GetData(), i);
     }
   }
   else
   {
     ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(0);
 
     this->SetVolume(volume->GetData(), 0);
   }
 }
 
 mitk::Image::~Image()
 {
   Clear();
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 3;
   m_ReferenceCountLock.Unlock();
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 0;
   m_ReferenceCountLock.Unlock();
   if(m_OffsetTable != NULL)
     delete [] m_OffsetTable;
 
   if(m_ImageStatistics != NULL)
     delete m_ImageStatistics;
 }
 
 const mitk::PixelType mitk::Image::GetPixelType(int n) const
 {
   return this->m_ImageDescriptor->GetChannelTypeById(n);
 }
 
 unsigned int mitk::Image::GetDimension() const
 {
   return m_Dimension;
 }
 
 unsigned int mitk::Image::GetDimension(int i) const
 {
   if((i>=0) && (i<(int)m_Dimension))
     return m_Dimensions[i];
   return 1;
 }
 
 void* mitk::Image::GetData()
 {
   if(m_Initialized==false)
   {
     if(GetSource().IsNull())
       return NULL;
     if(GetSource()->Updating()==false)
       GetSource()->UpdateOutputInformation();
   }
   m_CompleteData=GetChannelData();
 
   // update channel's data
   // if data was not available at creation point, the m_Data of channel descriptor is NULL
   // if data present, it won't be overwritten
   m_ImageDescriptor->GetChannelDescriptor(0).SetData(m_CompleteData->GetData());
 
   return m_CompleteData->GetData();
 }
 
 
 template <class T>
 void AccessPixel( const mitk::PixelType ptype, void* data, const unsigned int offset, double& value )
 {
   value = 0.0;
   if( data == NULL ) return;
 
   if(ptype.GetBpe() != 24)
   {
     value = (double) (((T*) data)[ offset ]);
   }
   else
   {
     const unsigned int rgboffset = 3 * offset;
 
     double returnvalue = (((T*) data)[rgboffset ]);
     returnvalue += (((T*) data)[rgboffset + 1]);
     returnvalue += (((T*) data)[rgboffset + 2]);
     value = returnvalue;
   }
 
 }
 
 double mitk::Image::GetPixelValueByIndex(const mitk::Index3D &position, unsigned int timestep)
 {
   double value = 0;
   if (this->GetTimeSteps() < timestep)
   {
     timestep = this->GetTimeSteps();
   }
 
   value = 0.0;
 
   const unsigned int* imageDims = this->m_ImageDescriptor->GetDimensions();
   const mitk::PixelType ptype = this->m_ImageDescriptor->GetChannelTypeById(0);
 
   // Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
   // (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
   // bug-11978 : we still need to catch index with negative values
   if ( position[0] < 0 ||
        position[1] < 0 ||
        position[2] < 0 )
   {
     MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
   }
   // check if the given position is inside the index range of the image, the 3rd dimension needs to be compared only if the dimension is not 0
   else if ( (unsigned int)position[0] >= imageDims[0] ||
             (unsigned int)position[1] >= imageDims[1] ||
             ( imageDims[2] && (unsigned int)position[2] >= imageDims[2] ))
   {
     MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
   }
   else
   {
     const unsigned int offset = position[0] + position[1]*imageDims[0] + position[2]*imageDims[0]*imageDims[1] + timestep*imageDims[0]*imageDims[1]*imageDims[2];
 
     mitkPixelTypeMultiplex3( AccessPixel, ptype, this->GetData(), offset, value );
   }
 
   return value;
 }
 
 double mitk::Image::GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep)
 {
   double value = 0.0;
   if (this->GetTimeSteps() < timestep)
   {
     timestep = this->GetTimeSteps();
   }
 
   Index3D itkIndex;
   this->GetGeometry()->WorldToIndex(position, itkIndex);
 
   value = this->GetPixelValueByIndex( itkIndex, timestep);
 
   return value;
 }
 
 mitk::ImageVtkAccessor* mitk::Image::GetVtkImageData(int t, int n)
 {
   if(m_Initialized==false)
   {
     if(GetSource().IsNull())
       return NULL;
     if(GetSource()->Updating()==false)
       GetSource()->UpdateOutputInformation();
   }
   ImageDataItemPointer volume=GetVolumeData(t, n);
   if(volume.GetPointer()==NULL || volume->GetVtkImageData(this) == NULL)
     return NULL;
 
   SlicedGeometry3D* geom3d = GetSlicedGeometry(t);
   const mitk::Vector3D vspacing = (geom3d->GetSpacing());
   double dspacing[3] = {vspacing[0],vspacing[1],vspacing[2]};
   volume->GetVtkImageData(this)->SetSpacing( dspacing );
 
   return volume->GetVtkImageData(this);
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidSlice(s,t,n)==false) return NULL;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // slice directly available?
   int pos=GetSliceIndex(s,t,n);
   if(m_Slices[pos].GetPointer()!=NULL)
     return m_Slices[pos];
 
   // is slice available as part of a volume that is available?
   ImageDataItemPointer sl, ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
   {
     sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // is slice available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
   {
     sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // slice is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir mussen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, s);
     m_RequestedRegion.SetIndex(3, t);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, 1);
     m_RequestedRegion.SetSize(3, 1);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     if(IsSliceSet(s,t,n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetSliceData(s,t,n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateSliceData(s,t,n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidVolume(t,n)==false) return NULL;
 
   ImageDataItemPointer ch, vol;
 
   // volume directly available?
   int pos=GetVolumeIndex(t,n);
   vol=m_Volumes[pos];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return vol;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is volume available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
   {
     vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     vol->SetComplete(true);
     return m_Volumes[pos]=vol;
   }
 
   // let's see if all slices of the volume are set, so that we can (could) combine them to a volume
   bool complete=true;
   unsigned int s;
   for(s=0;s<m_Dimensions[2];++s)
   {
     if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
     {
       complete=false;
       break;
     }
   }
   if(complete)
   {
     // if there is only single slice we do not need to combine anything
     if(m_Dimensions[2]<=1)
     {
       ImageDataItemPointer sl;
       sl=GetSliceData(0,t,n,data,importMemoryManagement);
       vol=new ImageDataItem(*sl, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory);
       vol->SetComplete(true);
     }
     else
     {
       mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
 
       vol=m_Volumes[pos];
       // ok, let's combine the slices!
       if(vol.GetPointer()==NULL)
         vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
       vol->SetComplete(true);
       size_t size=m_OffsetTable[2]*(ptypeSize);
       for(s=0;s<m_Dimensions[2];++s)
       {
         int posSl;
         ImageDataItemPointer sl;
         posSl=GetSliceIndex(s,t,n);
 
         sl=m_Slices[posSl];
         if(sl->GetParent()!=vol)
         {
           // copy data of slices in volume
           size_t offset = ((size_t) s)*size;
           std::memcpy(static_cast<char*>(vol->GetData())+offset, sl->GetData(), size);
 
           // FIXME mitkIpPicDescriptor * pic = sl->GetPicDescriptor();
 
           // replace old slice with reference to volume
           sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*size);
           sl->SetComplete(true);
           //mitkIpFuncCopyTags(sl->GetPicDescriptor(), pic);
           m_Slices[posSl]=sl;
         }
       }
       //if(vol->GetPicDescriptor()->info->tags_head==NULL)
       //  mitkIpFuncCopyTags(vol->GetPicDescriptor(), m_Slices[GetSliceIndex(0,t,n)]->GetPicDescriptor());
     }
     return m_Volumes[pos]=vol;
   }
 
   // volume is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir muessen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, 0);
     m_RequestedRegion.SetIndex(3, t);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, m_Dimensions[2]);
     m_RequestedRegion.SetSize(3, 1);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     if(IsVolumeSet(t,n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetVolumeData(t,n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateVolumeData(t,n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidChannel(n)==false) return NULL;
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return ch;
 
   // let's see if all volumes are set, so that we can (could) combine them to a channel
   if(IsChannelSet(n))
   {
     // if there is only one time frame we do not need to combine anything
     if(m_Dimensions[3]<=1)
     {
       vol=GetVolumeData(0,n,data,importMemoryManagement);
       ch=new ImageDataItem(*vol, m_ImageDescriptor, m_ImageDescriptor->GetNumberOfDimensions(), data, importMemoryManagement == ManageMemory);
       ch->SetComplete(true);
     }
     else
     {
       const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
       ch=m_Channels[n];
       // ok, let's combine the volumes!
       if(ch.GetPointer()==NULL)
         ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
       ch->SetComplete(true);
       size_t size=m_OffsetTable[m_Dimension-1]*(ptypeSize);
       unsigned int t;
       ImageDataItemPointerArray::iterator slicesIt = m_Slices.begin()+n*m_Dimensions[2]*m_Dimensions[3];
       for(t=0;t<m_Dimensions[3];++t)
       {
         int posVol;
         ImageDataItemPointer vol;
 
         posVol=GetVolumeIndex(t,n);
         vol=GetVolumeData(t,n,data,importMemoryManagement);
 
         if(vol->GetParent()!=ch)
         {
           // copy data of volume in channel
           size_t offset = ((size_t) t)*m_OffsetTable[3]*(ptypeSize);
           std::memcpy(static_cast<char*>(ch->GetData())+offset, vol->GetData(), size);
 
           // REVEIW FIX mitkIpPicDescriptor * pic = vol->GetPicDescriptor();
 
           // replace old volume with reference to channel
           vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, offset);
           vol->SetComplete(true);
           //mitkIpFuncCopyTags(vol->GetPicDescriptor(), pic);
 
           m_Volumes[posVol]=vol;
 
           // get rid of slices - they may point to old volume
           ImageDataItemPointer dnull=NULL;
           for(unsigned int i = 0; i < m_Dimensions[2]; ++i, ++slicesIt)
           {
             assert(slicesIt != m_Slices.end());
             *slicesIt = dnull;
           }
         }
       }
       // REVIEW FIX
       //   if(ch->GetPicDescriptor()->info->tags_head==NULL)
       //     mitkIpFuncCopyTags(ch->GetPicDescriptor(), m_Volumes[GetVolumeIndex(0,n)]->GetPicDescriptor());
     }
     return m_Channels[n]=ch;
   }
 
   // channel is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir muessen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, 0);
     m_RequestedRegion.SetIndex(3, 0);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, m_Dimensions[2]);
     m_RequestedRegion.SetSize(3, m_Dimensions[3]);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     // did it work?
     if(IsChannelSet(n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetChannelData(n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateChannelData(n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 }
 
 bool mitk::Image::IsSliceSet(int s, int t, int n) const
 {
   if(IsValidSlice(s,t,n)==false) return false;
 
   if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()!=NULL)
     return true;
 
   ImageDataItemPointer ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return true;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return true;
   return false;
 }
 
 bool mitk::Image::IsVolumeSet(int t, int n) const
 {
   if(IsValidVolume(t,n)==false) return false;
   ImageDataItemPointer ch, vol;
 
   // volume directly available?
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return true;
 
   // is volume available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return true;
 
   // let's see if all slices of the volume are set, so that we can (could) combine them to a volume
   unsigned int s;
   for(s=0;s<m_Dimensions[2];++s)
     if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
       return false;
   return true;
 }
 
 bool mitk::Image::IsChannelSet(int n) const
 {
   if(IsValidChannel(n)==false) return false;
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
 
     return true;
   // let's see if all volumes are set, so that we can (could) combine them to a channel
   unsigned int t;
   for(t=0;t<m_Dimensions[3];++t)
     if(IsVolumeSet(t,n)==false)
       return false;
   return true;
 }
 
 bool mitk::Image::SetSlice(const void *data, int s, int t, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportSlice(const_cast<void*>(data), s, t, n, CopyMemory);
 }
 
 bool mitk::Image::SetVolume(const void *data, int t, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportVolume(const_cast<void*>(data), t, n, CopyMemory);
 }
 
 bool mitk::Image::SetChannel(const void *data, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportChannel(const_cast<void*>(data), n, CopyMemory);
 }
 
 bool mitk::Image::SetImportSlice(void *data, int s, int t, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidSlice(s,t,n)==false) return false;
   ImageDataItemPointer sl;
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   if(IsSliceSet(s,t,n))
   {
     sl=GetSliceData(s,t,n,data,importMemoryManagement);
     if(sl->GetManageMemory()==false)
     {
       sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
       if(sl.GetPointer()==NULL) return false;
     }
     if ( sl->GetData() != data )
       std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
     sl->Modified();
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
     if(sl.GetPointer()==NULL) return false;
     if ( sl->GetData() != data )
       std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
     //we just added a missing slice, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 bool mitk::Image::SetImportVolume(void *data, int t, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidVolume(t,n)==false) return false;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
   ImageDataItemPointer vol;
   if(IsVolumeSet(t,n))
   {
     vol=GetVolumeData(t,n,data,importMemoryManagement);
     if(vol->GetManageMemory()==false)
     {
       vol=AllocateVolumeData(t,n,data,importMemoryManagement);
       if(vol.GetPointer()==NULL) return false;
     }
     if ( vol->GetData() != data )
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
     vol->Modified();
     vol->SetComplete(true);
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     vol=AllocateVolumeData(t,n,data,importMemoryManagement);
     if(vol.GetPointer()==NULL) return false;
     if ( vol->GetData() != data )
     {
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
     }
     vol->SetComplete(true);
     this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( vol->GetData() );
     //we just added a missing Volume, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 bool mitk::Image::SetImportChannel(void *data, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidChannel(n)==false) return false;
 
   // channel descriptor
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   ImageDataItemPointer ch;
   if(IsChannelSet(n))
   {
     ch=GetChannelData(n,data,importMemoryManagement);
     if(ch->GetManageMemory()==false)
     {
       ch=AllocateChannelData(n,data,importMemoryManagement);
       if(ch.GetPointer()==NULL) return false;
     }
     if ( ch->GetData() != data )
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
     ch->Modified();
     ch->SetComplete(true);
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     ch=AllocateChannelData(n,data,importMemoryManagement);
     if(ch.GetPointer()==NULL) return false;
     if ( ch->GetData() != data )
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
     ch->SetComplete(true);
 
     this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( ch->GetData() );
     //we just added a missing Channel, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 void mitk::Image::Initialize()
 {
   ImageDataItemPointerArray::iterator it, end;
   for( it=m_Slices.begin(), end=m_Slices.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   for( it=m_Volumes.begin(), end=m_Volumes.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   for( it=m_Channels.begin(), end=m_Channels.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   m_CompleteData = NULL;
 
   if( m_ImageStatistics == NULL)
   {
     m_ImageStatistics = new mitk::ImageStatisticsHolder( this );
   }
 
   SetRequestedRegionToLargestPossibleRegion();
 }
 
 void mitk::Image::Initialize(const mitk::ImageDescriptor::Pointer inDesc)
 {
   // store the descriptor
   this->m_ImageDescriptor = inDesc;
 
   // initialize image
   this->Initialize( inDesc->GetChannelDescriptor(0).GetPixelType(), inDesc->GetNumberOfDimensions(), inDesc->GetDimensions(), 1 );
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels)
 {
   Clear();
 
   m_Dimension=dimension;
 
   if(!dimensions)
     itkExceptionMacro(<< "invalid zero dimension image");
 
   unsigned int i;
   for(i=0;i<dimension;++i)
   {
     if(dimensions[i]<1)
       itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
   }
 
   // create new array since the old was deleted
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
 
   // initialize the first four dimensions to 1, the remaining 4 to 0
   FILL_C_ARRAY(m_Dimensions, 4, 1u);
   FILL_C_ARRAY((m_Dimensions+4), 4, 0u);
 
   // copy in the passed dimension information
   std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
 
   this->m_ImageDescriptor = mitk::ImageDescriptor::New();
   this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
 
   for(i=0;i<4;++i)
   {
     m_LargestPossibleRegion.SetIndex(i, 0);
     m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
   }
   m_LargestPossibleRegion.SetIndex(i, 0);
   m_LargestPossibleRegion.SetSize(i, channels);
 
   if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
   {
     delete [] m_Dimensions;
     m_Dimensions = NULL;
     return;
   }
 
   for( unsigned int i=0u; i<channels; i++)
   {
     this->m_ImageDescriptor->AddNewChannel( type );
   }
 
   PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
   planegeometry->InitializeStandardPlane(m_Dimensions[0], m_Dimensions[1]);
 
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
   slicedGeometry->InitializeEvenlySpaced(planegeometry, m_Dimensions[2]);
 
   if(dimension>=4)
   {
     TimeBounds timebounds;
     timebounds[0] = 0.0;
     timebounds[1] = 1.0;
     slicedGeometry->SetTimeBounds(timebounds);
   }
 
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
   for (TimeStepType step = 0; step < timeGeometry->CountTimeSteps(); ++step)
   {
     timeGeometry->GetGeometryForTimeStep(step)->ImageGeometryOn();
   }
   SetTimeGeometry(timeGeometry);
 
   ImageDataItemPointer dnull=NULL;
 
   m_Channels.assign(GetNumberOfChannels(), dnull);
 
   m_Volumes.assign(GetNumberOfChannels()*m_Dimensions[3], dnull);
 
   m_Slices.assign(GetNumberOfChannels()*m_Dimensions[3]*m_Dimensions[2], dnull);
 
   ComputeOffsetTable();
 
   Initialize();
 
   m_Initialized = true;
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::BaseGeometry& geometry, unsigned int channels, int tDim )
 {
   mitk::ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   itk::LightObject::Pointer lopointer = geometry.Clone();
   timeGeometry->Initialize(dynamic_cast<BaseGeometry*>(lopointer.GetPointer()), tDim);
   this->Initialize(type, *timeGeometry, channels, tDim);
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::TimeGeometry& geometry, unsigned int channels, int tDim )
 {
   unsigned int dimensions[5];
   dimensions[0] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(0)+0.5);
   dimensions[1] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(1)+0.5);
   dimensions[2] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(2)+0.5);
   dimensions[3] = (tDim > 0) ? tDim : geometry.CountTimeSteps();
   dimensions[4] = 0;
 
   unsigned int dimension = 2;
   if ( dimensions[2] > 1 )
     dimension = 3;
   if ( dimensions[3] > 1 )
     dimension = 4;
 
   Initialize( type, dimension, dimensions, channels );
   if (geometry.CountTimeSteps() > 1)
   {
     TimeGeometry::Pointer cloned = geometry.Clone();
     SetTimeGeometry(cloned.GetPointer());
   }
   else
     Superclass::SetGeometry(geometry.GetGeometryForTimeStep(0));
 /* //Old //TODO_GOETZ Really necessary?
   mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBoxInWorld()->GetBounds();
   if( (bounds[0] != 0.0) || (bounds[2] != 0.0) || (bounds[4] != 0.0) )
   {
     SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
 
     mitk::Point3D origin; origin.Fill(0.0);
     slicedGeometry->IndexToWorld(origin, origin);
 
     bounds[1]-=bounds[0]; bounds[3]-=bounds[2]; bounds[5]-=bounds[4];
     bounds[0] = 0.0;      bounds[2] = 0.0;      bounds[4] = 0.0;
     this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
     slicedGeometry->SetBounds(bounds);
     slicedGeometry->GetIndexToWorldTransform()->SetOffset(origin.GetVnlVector().data_block());
 
     ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
     timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
     SetTimeGeometry(timeGeometry);
   }*/
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry2d, bool flipped, unsigned int channels, int tDim )
 {
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
   slicedGeometry->InitializeEvenlySpaced(static_cast<PlaneGeometry*>(geometry2d.Clone().GetPointer()), sDim, flipped);
   Initialize(type, *slicedGeometry, channels, tDim);
 }
 
 void mitk::Image::Initialize(const mitk::Image* image)
 {
   Initialize(image->GetPixelType(), *image->GetTimeGeometry());
 }
 
 void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
 {
   if(vtkimagedata==NULL) return;
 
   m_Dimension=vtkimagedata->GetDataDimension();
   unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
   for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
   if(m_Dimension<4)
   {
     unsigned int *p;
     for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
       *p=1;
   }
 
   if(pDim>=0)
   {
     tmpDimensions[1]=pDim;
     if(m_Dimension < 2)
       m_Dimension = 2;
   }
   if(sDim>=0)
   {
     tmpDimensions[2]=sDim;
     if(m_Dimension < 3)
       m_Dimension = 3;
   }
   if(tDim>=0)
   {
     tmpDimensions[3]=tDim;
     if(m_Dimension < 4)
       m_Dimension = 4;
   }
 
 
   switch ( vtkimagedata->GetScalarType() )
   {
   case VTK_BIT:
   case VTK_CHAR:
     //pixelType.Initialize(typeid(char), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<char>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_CHAR:
     //pixelType.Initialize(typeid(unsigned char), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned char>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_SHORT:
     //pixelType.Initialize(typeid(short), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<short>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_SHORT:
     //pixelType.Initialize(typeid(unsigned short), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned short>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_INT:
     //pixelType.Initialize(typeid(int), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<int>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_INT:
     //pixelType.Initialize(typeid(unsigned int), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned int>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_LONG:
     //pixelType.Initialize(typeid(long), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<long>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_LONG:
     //pixelType.Initialize(typeid(unsigned long), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned long>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_FLOAT:
     //pixelType.Initialize(typeid(float), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<float>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_DOUBLE:
     //pixelType.Initialize(typeid(double), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<double>(), m_Dimension, tmpDimensions, channels);
     break;
   default:
     break;
   }
   /*
   Initialize(pixelType,
     m_Dimension,
     tmpDimensions,
     channels);
 */
 
   const double *spacinglist = vtkimagedata->GetSpacing();
   Vector3D spacing;
   FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
   if(m_Dimension>=2)
     spacing[1]=spacinglist[1];
   if(m_Dimension>=3)
     spacing[2]=spacinglist[2];
 
   // access origin of vtkImage
   Point3D origin;
   double vtkorigin[3];
   vtkimagedata->GetOrigin(vtkorigin);
   FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
   if(m_Dimension>=2)
     origin[1]=vtkorigin[1];
   if(m_Dimension>=3)
     origin[2]=vtkorigin[2];
 
   SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
 
   // re-initialize PlaneGeometry with origin and direction
-  PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetGeometry2D(0));
+  PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetPlaneGeometry(0));
   planeGeometry->SetOrigin(origin);
 
   // re-initialize SlicedGeometry3D
   slicedGeometry->SetOrigin(origin);
   slicedGeometry->SetSpacing(spacing);
 
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
   SetTimeGeometry(timeGeometry);
 
   delete [] tmpDimensions;
 }
 
 bool mitk::Image::IsValidSlice(int s, int t, int n) const
 {
   if(m_Initialized)
     return ((s>=0) && (s<(int)m_Dimensions[2]) && (t>=0) && (t< (int) m_Dimensions[3]) && (n>=0) && (n< (int)GetNumberOfChannels()));
   else
     return false;
 }
 
 bool mitk::Image::IsValidVolume(int t, int n) const
 {
   if(m_Initialized)
     return IsValidSlice(0, t, n);
   else
     return false;
 }
 
 bool mitk::Image::IsValidChannel(int n) const
 {
   if(m_Initialized)
     return IsValidSlice(0, 0, n);
   else
     return false;
 }
 
 void mitk::Image::ComputeOffsetTable()
 {
   if(m_OffsetTable!=NULL)
     delete [] m_OffsetTable;
 
   m_OffsetTable=new size_t[m_Dimension>4 ? m_Dimension+1 : 4+1];
 
   unsigned int i;
   size_t num=1;
   m_OffsetTable[0] = 1;
   for (i=0; i < m_Dimension; ++i)
   {
     num *= m_Dimensions[i];
     m_OffsetTable[i+1] = num;
   }
   for (;i < 4; ++i)
     m_OffsetTable[i+1] = num;
 }
 
 bool mitk::Image::IsValidTimeStep(int t) const
 {
   return ( ( m_Dimension >= 4 && t <= (int)m_Dimensions[3] && t > 0 ) || (t == 0) );
 }
 
 void mitk::Image::Expand(unsigned int timeSteps)
 {
   if(timeSteps < 1) itkExceptionMacro(<< "Invalid timestep in Image!");
   Superclass::Expand(timeSteps);
 }
 
 int mitk::Image::GetSliceIndex(int s, int t, int n) const
 {
   if(IsValidSlice(s,t,n)==false) return false;
   return ((size_t)s)+((size_t) t)*m_Dimensions[2]+((size_t) n)*m_Dimensions[3]*m_Dimensions[2]; //??
 }
 
 int mitk::Image::GetVolumeIndex(int t, int n) const
 {
   if(IsValidVolume(t,n)==false) return false;
   return ((size_t)t)+((size_t) n)*m_Dimensions[3]; //??
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   int pos;
   pos=GetSliceIndex(s,t,n);
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is slice available as part of a volume that is available?
   ImageDataItemPointer sl, ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if(vol.GetPointer()!=NULL)
   {
     sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // is slice available as part of a channel that is available?
   ch=m_Channels[n];
   if(ch.GetPointer()!=NULL)
   {
     sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // allocate new volume (instead of a single slice to keep data together!)
   m_Volumes[GetVolumeIndex(t,n)]=vol=AllocateVolumeData(t,n,NULL,importMemoryManagement);
   sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
   sl->SetComplete(true);
   return m_Slices[pos]=sl;
 
   ////ALTERNATIVE:
   //// allocate new slice
   //sl=new ImageDataItem(*m_PixelType, 2, m_Dimensions);
   //m_Slices[pos]=sl;
   //return vol;
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   int pos;
   pos=GetVolumeIndex(t,n);
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is volume available as part of a channel that is available?
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if(ch.GetPointer()!=NULL)
   {
     vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data,importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     return m_Volumes[pos]=vol;
   }
 
   mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
 
   // allocate new volume
   if(importMemoryManagement == CopyMemory)
   {
     vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
     if(data != NULL)
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
   }
   else
   {
     vol=new ImageDataItem( chPixelType, 3, m_Dimensions, data, importMemoryManagement == ManageMemory);
   }
   m_Volumes[pos]=vol;
   return vol;
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   ImageDataItemPointer ch;
   // allocate new channel
   if(importMemoryManagement == CopyMemory)
   {
     const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
     ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
     if(data != NULL)
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
   }
   else
   {
     ch=new ImageDataItem(this->m_ImageDescriptor, data, importMemoryManagement == ManageMemory);
   }
   m_Channels[n]=ch;
   return ch;
 }
 
 unsigned int* mitk::Image::GetDimensions() const
 {
   return m_Dimensions;
 }
 
 void mitk::Image::Clear()
 {
   Superclass::Clear();
   delete [] m_Dimensions;
   m_Dimensions = NULL;
 }
 
 void mitk::Image::SetGeometry(BaseGeometry* aGeometry3D)
 {
   // Please be aware of the 0.5 offset/pixel-center issue! See Geometry documentation for further information
 
   if(aGeometry3D->GetImageGeometry()==false)
   {
     MITK_INFO << "WARNING: Applied a non-image geometry onto an image. Please be SURE that this geometry is pixel-center-based! If it is not, you need to call Geometry3D->ChangeImageGeometryConsideringOriginOffset(true) before calling image->setGeometry(..)\n";
   }
   Superclass::SetGeometry(aGeometry3D);
   for (TimeStepType step = 0; step < GetTimeGeometry()->CountTimeSteps(); ++step)
     GetTimeGeometry()->GetGeometryForTimeStep(step)->ImageGeometryOn();
 }
 
 void mitk::Image::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   unsigned char i;
   if(m_Initialized)
   {
     os << indent << " Dimension: " << m_Dimension << std::endl;
     os << indent << " Dimensions: ";
     for(i=0; i < m_Dimension; ++i)
       os << GetDimension(i) << " ";
     os << std::endl;
 
     for(unsigned int ch=0; ch < this->m_ImageDescriptor->GetNumberOfChannels(); ch++)
     {
       mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(ch);
 
       os << indent << " Channel: " << this->m_ImageDescriptor->GetChannelName(ch) << std::endl;
       os << indent << " PixelType: " << chPixelType.GetPixelTypeAsString() << std::endl;
       os << indent << " BytesPerElement: " << chPixelType.GetSize() << std::endl;
       os << indent << " ComponentType: " << chPixelType.GetComponentTypeAsString() << std::endl;
       os << indent << " NumberOfComponents: " << chPixelType.GetNumberOfComponents() << std::endl;
       os << indent << " BitsPerComponent: " << chPixelType.GetBitsPerComponent() << std::endl;
     }
 
   }
   else
   {
     os << indent << " Image not initialized: m_Initialized: false" << std::endl;
   }
 
   Superclass::PrintSelf(os,indent);
 }
 
 bool mitk::Image::IsRotated() const
 {
   const mitk::BaseGeometry* geo = this->GetGeometry();
   bool ret = false;
 
   if(geo)
   {
     const vnl_matrix_fixed<ScalarType, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
     mitk::ScalarType ref = 0;
     for(short k = 0; k < 3; ++k)
       ref += mx[k][k];
     ref/=1000;  // Arbitrary value; if a non-diagonal (nd) element is bigger then this, matrix is considered nd.
 
     for(short i = 0; i < 3; ++i)
     {
       for(short j = 0; j < 3; ++j)
       {
         if(i != j)
         {
           if(std::abs(mx[i][j]) > ref) // matrix is nd
             ret = true;
         }
       }
     }
   }
   return ret;
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMin(int t) const
 {
   return m_ImageStatistics->GetScalarValueMin(t);
 }
 
 //## \brief Get the maximum for scalar images
 mitk::ScalarType mitk::Image::GetScalarValueMax(int t) const
 {
   return m_ImageStatistics->GetScalarValueMax(t);
 }
 
 //## \brief Get the second smallest value for scalar images
 mitk::ScalarType mitk::Image::GetScalarValue2ndMin(int t) const
 {
   return m_ImageStatistics->GetScalarValue2ndMin(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMinNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValueMinNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMinNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValue2ndMinNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMax(int t) const
 {
   return m_ImageStatistics->GetScalarValue2ndMax(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMaxNoRecompute( unsigned int t) const
 {
   return m_ImageStatistics->GetScalarValueMaxNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMaxNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValue2ndMaxNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetCountOfMinValuedVoxels(int t ) const
 {
   return m_ImageStatistics->GetCountOfMinValuedVoxels(t);
 }
 
 mitk::ScalarType mitk::Image::GetCountOfMaxValuedVoxels(int t) const
 {
   return m_ImageStatistics->GetCountOfMaxValuedVoxels(t);
 }
 
 unsigned int mitk::Image::GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t  ) const
 {
   return m_ImageStatistics->GetCountOfMaxValuedVoxelsNoRecompute(t);
 }
 
 unsigned int mitk::Image::GetCountOfMinValuedVoxelsNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetCountOfMinValuedVoxelsNoRecompute(t);
 }
 
 bool mitk::Equal(const mitk::Image* leftHandSide, const mitk::Image* rightHandSide, ScalarType eps, bool verbose)
 {
   if((leftHandSide == NULL)  || (rightHandSide == NULL))
   {
     MITK_ERROR << "mitk::Equal(const mitk::Image* leftHandSide, const mitk::Image* rightHandSide, ScalarType eps, bool verbose) does not work with NULL pointer input.";
     return false;
   }
   return mitk::Equal( *leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const mitk::Image& leftHandSide, const mitk::Image& rightHandSide, ScalarType eps, bool verbose)
 {
   bool returnValue = true;
 
   // Dimensionality
   if( rightHandSide.GetDimension() != leftHandSide.GetDimension() )
   {
     if(verbose)
     {
       MITK_INFO << "[( Image )] Dimensionality differs.";
       MITK_INFO << "leftHandSide is " << leftHandSide.GetDimension()
        << "rightHandSide is " << rightHandSide.GetDimension();
     }
     returnValue = false;
   }
 
   // Pair-wise dimension (size) comparison
   unsigned int minDimensionality = std::min(rightHandSide.GetDimension(),leftHandSide.GetDimension());
   for( unsigned int i=0; i< minDimensionality; ++i)
   {
     if( rightHandSide.GetDimension(i) != leftHandSide.GetDimension(i) )
     {
       returnValue = false;
       if(verbose)
       {
         MITK_INFO << "[( Image )] dimension differs.";
         MITK_INFO << "leftHandSide->GetDimension("<<i<<") is " << leftHandSide.GetDimension(i)
          << "rightHandSide->GetDimension("<<i<<") is " << rightHandSide.GetDimension(i);
       }
     }
   }
 
   // Pixeltype
   mitk::PixelType pixelTypeRightHandSide = rightHandSide.GetPixelType();
   mitk::PixelType pixelTypeLeftHandSide = leftHandSide.GetPixelType();
   if( !( pixelTypeRightHandSide == pixelTypeLeftHandSide ) )
   {
     if(verbose)
     {
       MITK_INFO << "[( Image )] PixelType differs.";
       MITK_INFO << "leftHandSide is " << pixelTypeLeftHandSide.GetTypeAsString()
        << "rightHandSide is " << pixelTypeRightHandSide.GetTypeAsString();
     }
     returnValue = false;
   }
 
   // Geometries
   if( !mitk::Equal(  leftHandSide.GetGeometry(),
                      rightHandSide.GetGeometry(), eps, verbose) )
   {
     if(verbose)
     {
       MITK_INFO << "[( Image )] Geometries differ.";
     }
     returnValue = false;
   }
 
   // Pixel values - default mode [ 0 threshold in difference ]
   // compare only if all previous checks were successfull, otherwise the ITK filter will throw an exception
   if( returnValue )
   {
     mitk::CompareImageDataFilter::Pointer compareFilter = mitk::CompareImageDataFilter::New();
 
     compareFilter->SetInput(0, &rightHandSide);
     compareFilter->SetInput(1, &leftHandSide);
     compareFilter->SetTolerance(eps);
     compareFilter->Update();
 
     if(( !compareFilter->GetResult() ) )
     {
       returnValue = false;
       if(verbose)
       {
         MITK_INFO << "[(Image)] Pixel values differ: ";
         compareFilter->GetCompareResults().PrintSelf();
       }
     }
   }
 
   return returnValue;
 }
diff --git a/Core/Code/DataManagement/mitkImage.h b/Core/Code/DataManagement/mitkImage.h
index 3f16d79702..6ac2d1aff7 100644
--- a/Core/Code/DataManagement/mitkImage.h
+++ b/Core/Code/DataManagement/mitkImage.h
@@ -1,735 +1,735 @@
 /*===================================================================
 
 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 MITKIMAGE_H_HEADER_INCLUDED_C1C2FCD2
 #define MITKIMAGE_H_HEADER_INCLUDED_C1C2FCD2
 
 #include <MitkCoreExports.h>
 #include "mitkSlicedData.h"
 #include "mitkBaseData.h"
 #include "mitkLevelWindow.h"
 #include "mitkPlaneGeometry.h"
 #include <mitkProportionalTimeGeometry.h>
 #include "mitkImageDataItem.h"
 #include "mitkImageDescriptor.h"
 #include "mitkImageAccessorBase.h"
 #include "mitkImageVtkAccessor.h"
 
 //DEPRECATED
 #include <mitkTimeSlicedGeometry.h>
 
 #ifndef __itkHistogram_h
 #include <itkHistogram.h>
 #endif
 
 
 class vtkImageData;
 
 namespace mitk {
 
 class SubImageSelector;
 class ImageTimeSelector;
 
 class ImageStatisticsHolder;
 
 //##Documentation
 //## @brief Image class for storing images
 //##
 //## Can be asked for header information, the data vector,
 //## the mitkIpPicDescriptor struct or vtkImageData objects. If not the complete
 //## data is required, the appropriate SubImageSelector class should be used
 //## for access.
 //## Image organizes sets of slices (s x 2D), volumes (t x 3D) and channels (n
 //## x ND). Channels are for different kind of data, e.g., morphology in
 //## channel 0, velocities in channel 1. All channels must have the same Geometry! In
 //## particular, the dimensions of all channels are the same, only the pixel-type
 //## may differ between channels.
 //##
 //## For importing ITK images use of mitk::ITKImageImport is recommended, see
 //## \ref Adaptor.
 //##
 //## For ITK v3.8 and older: Converting coordinates from the ITK physical
 //## coordinate system (which does not support rotated images) to the MITK world
-//## coordinate system should be performed via the Geometry3D of the Image, see
-//## Geometry3D::WorldToItkPhysicalPoint.
+//## coordinate system should be performed via the BaseGeometry of the Image, see
+//## BaseGeometry::WorldToItkPhysicalPoint.
 //## @ingroup Data
 class MITK_CORE_EXPORT Image : public SlicedData
 {
   friend class SubImageSelector;
 
   friend class ImageAccessorBase;
   friend class ImageVtkAccessor;
   friend class ImageReadAccessor;
   friend class ImageWriteAccessor;
 
 public:
   mitkClassMacro(Image, SlicedData);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /** Smart Pointer type to a ImageDataItem. */
   typedef itk::SmartPointer<ImageDataItem> ImageDataItemPointer;
   typedef itk::Statistics::Histogram<double> HistogramType;
   typedef mitk::ImageStatisticsHolder* StatisticsHolderPointer;
 
   //## @param ImportMemoryManagementType This parameter is evaluated when setting new data to an image.
   //## The different options are:
   //## CopyMemory: Data to be set is copied and assigned to a new memory block. Data memory block will be freed on deletion of mitk::Image.
   //## MamageMemory: Data to be set will be referenced, and Data memory block will be freed on deletion of mitk::Image.
   //## Reference Memory: Data to be set will be referenced, but Data memory block will not be freed on deletion of mitk::Image.
   //## DontManageMemory = ReferenceMemory.
   enum ImportMemoryManagementType { CopyMemory, ManageMemory, ReferenceMemory, DontManageMemory = ReferenceMemory };
 
   //##Documentation
   //## @brief Vector container of SmartPointers to ImageDataItems;
   //## Class is only for internal usage to allow convenient access to all slices over iterators;
   //## See documentation of ImageDataItem for details.
   typedef std::vector<ImageDataItemPointer> ImageDataItemPointerArray;
 
 public:
   //##Documentation
   //## @brief Returns the PixelType of channel @a n.
   const mitk::PixelType GetPixelType(int n = 0) const;
 
   //##Documentation
   //## @brief Get dimension of the image
   //##
   unsigned int GetDimension() const;
 
   //##Documentation
   //## @brief Get the size of dimension @a i (e.g., i=0 results in the number of pixels in x-direction).
   //##
   //## @sa GetDimensions()
   unsigned int GetDimension(int i) const;
 
   /** @brief Get the data vector of the complete image, i.e., of all channels linked together.
 
   If you only want to access a slice, volume at a specific time or single channel
   use one of the SubImageSelector classes.
    \deprecatedSince{2012_09} Please use image accessors instead: See Doxygen/Related-Pages/Concepts/Image. This method can be replaced by ImageWriteAccessor::GetData() or ImageReadAccessor::GetData() */
   DEPRECATED(virtual void* GetData());
 
 public:
   /** @brief Get the pixel value at one specific index position.
 
   The pixel type is always being converted to double.
    \deprecatedSince{2012_09} Please use image accessors instead: See Doxygen/Related-Pages/Concepts/Image. This method can be replaced by a method from ImagePixelWriteAccessor or ImagePixelReadAccessor */
   DEPRECATED(double GetPixelValueByIndex(const mitk::Index3D& position, unsigned int timestep = 0));
 
   /** @brief Get the pixel value at one specific world position.
 
   The pixel type is always being converted to double.
    \deprecatedSince{2012_09} Please use image accessors instead: See Doxygen/Related-Pages/Concepts/Image. This method can be replaced by a method from ImagePixelWriteAccessor or ImagePixelReadAccessor */
   DEPRECATED(double GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep = 0));
 
   //##Documentation
   //## @brief Get a volume at a specific time @a t of channel @a n as a vtkImageData.
   virtual ImageVtkAccessor* GetVtkImageData(int t = 0, int n = 0);
 
   //##Documentation
   //## @brief Get the complete image, i.e., all channels linked together, as a @a mitkIpPicDescriptor.
   //##
   //## If you only want to access a slice, volume at a specific time or single channel
   //## use one of the SubImageSelector classes.
   //virtual mitkIpPicDescriptor* GetPic();
 
   //##Documentation
   //## @brief Check whether slice @a s at time @a t in channel @a n is set
   virtual bool IsSliceSet(int s = 0, int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether volume at time @a t in channel @a n is set
   virtual bool IsVolumeSet(int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether the channel @a n is set
   virtual bool IsChannelSet(int n = 0) const;
 
   //##Documentation
   //## @brief Set @a data as slice @a s at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a slice (at least is not smaller than a slice), since there is
   //## no chance to check this.
   //##
   //## The data is copied to an array managed by the image. If the image shall
   //## reference the data, use SetImportSlice with ImportMemoryManagementType
   //## set to ReferenceMemory. For importing ITK images use of mitk::
   //## ITKImageImport is recommended.
   //## @sa SetPicSlice, SetImportSlice, SetImportVolume
   virtual bool SetSlice(const void *data, int s = 0, int t = 0, int n = 0);
 
   //##Documentation
   //## @brief Set @a data as volume at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a volume (at least is not smaller than a volume), since there is
   //## no chance to check this.
   //##
   //## The data is copied to an array managed by the image. If the image shall
   //## reference the data, use SetImportVolume with ImportMemoryManagementType
   //## set to ReferenceMemory. For importing ITK images use of mitk::
   //## ITKImageImport is recommended.
   //## @sa SetPicVolume, SetImportVolume
   virtual bool SetVolume(const void *data, int t = 0, int n = 0);
 
   //##Documentation
   //## @brief Set @a data in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a channel (at least is not smaller than a channel), since there is
   //## no chance to check this.
   //##
   //## The data is copied to an array managed by the image. If the image shall
   //## reference the data, use SetImportChannel with ImportMemoryManagementType
   //## set to ReferenceMemory. For importing ITK images use of mitk::
   //## ITKImageImport is recommended.
   //## @sa SetPicChannel, SetImportChannel
   virtual bool SetChannel(const void *data, int n = 0);
 
   //##Documentation
   //## @brief Set @a data as slice @a s at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a slice (at least is not smaller than a slice), since there is
   //## no chance to check this.
   //##
   //## The data is managed according to the parameter \a importMemoryManagement.
   //## @sa SetPicSlice
   virtual bool SetImportSlice(void *data, int s = 0, int t = 0, int n = 0, ImportMemoryManagementType importMemoryManagement = CopyMemory );
 
   //##Documentation
   //## @brief Set @a data as volume at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a volume (at least is not smaller than a volume), since there is
   //## no chance to check this.
   //##
   //## The data is managed according to the parameter \a importMemoryManagement.
   //## @sa SetPicVolume
   virtual bool SetImportVolume(void *data, int t = 0, int n = 0, ImportMemoryManagementType importMemoryManagement = CopyMemory );
 
   //##Documentation
   //## @brief Set @a data in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a channel (at least is not smaller than a channel), since there is
   //## no chance to check this.
   //##
   //## The data is managed according to the parameter \a importMemoryManagement.
   //## @sa SetPicChannel
   virtual bool SetImportChannel(void *data, int n = 0, ImportMemoryManagementType importMemoryManagement = CopyMemory );
 
   //##Documentation
   //## initialize new (or re-initialize) image information
   //## @warning Initialize() by pic assumes a plane, evenly spaced geometry starting at (0,0,0).
   virtual void Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels = 1);
 
   //##Documentation
-  //## initialize new (or re-initialize) image information by a Geometry3D
+  //## initialize new (or re-initialize) image information by a BaseGeometry
   //##
   //## @param tDim defines the number of time steps for which the Image should be initialized
   virtual void Initialize(const mitk::PixelType& type, const mitk::BaseGeometry& geometry, unsigned int channels = 1, int tDim=1);
 
   /**
-  * initialize new (or re-initialize) image information by a Geometry3D
+  * initialize new (or re-initialize) image information by a TimeGeometry
   *
   * @param tDim defines the number of time steps for which the Image should be initialized
   * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
   */
   DEPRECATED(virtual void Initialize(const mitk::PixelType& /*type*/, const mitk::TimeSlicedGeometry* /*geometry*/, unsigned int /*channels = 1*/, int /*tDim=1*/)){}
 
   /**
   * \brief Initialize new (or re-initialize) image information by a TimeGeometry
   *
   * \param tDim override time dimension if the value is bigger than 0 (Default -1)
   */
   virtual void Initialize(const mitk::PixelType& type, const mitk::TimeGeometry& geometry, unsigned int channels = 1, int tDim=-1 );
 
   //##Documentation
   //## initialize new (or re-initialize) image information by a PlaneGeometry and number of slices
   //##
   //## Initializes the bounding box according to the width/height of the
   //## PlaneGeometry and @a sDim via SlicedGeometry3D::InitializeEvenlySpaced.
   //## The spacing is calculated from the PlaneGeometry.
   //## \sa SlicedGeometry3D::InitializeEvenlySpaced
   virtual void Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry2d, bool flipped = false, unsigned int channels = 1, int tDim=1);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by another
   //## mitk-image.
   //## Only the header is used, not the data vector!
   //##
   virtual void Initialize(const mitk::Image* image);
 
   virtual void Initialize(const mitk::ImageDescriptor::Pointer inDesc);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by @a pic.
   //## Dimensions and @a Geometry3D /@a PlaneGeometry are set according
   //## to the tags in @a pic.
   //## Only the header is used, not the data vector! Use SetPicVolume(pic)
   //## to set the data vector.
   //##
   //## @param tDim override time dimension (@a n[3]) in @a pic (if >0)
   //## @param sDim override z-space dimension (@a n[2]) in @a pic (if >0)
   //## @warning Initialize() by pic assumes a plane, evenly spaced geometry starting at (0,0,0).
   //virtual void Initialize(const mitkIpPicDescriptor* pic, int channels = 1, int tDim = -1, int sDim = -1);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by @a vtkimagedata,
   //## a vtk-image.
   //## Only the header is used, not the data vector! Use
   //## SetVolume(vtkimage->GetScalarPointer()) to set the data vector.
   //##
   //## @param tDim override time dimension in @a vtkimagedata (if >0 and <)
   //## @param sDim override z-space dimension in @a vtkimagedata (if >0 and <)
   //## @param pDim override y-space dimension in @a vtkimagedata (if >0 and <)
   virtual void Initialize(vtkImageData* vtkimagedata, int channels = 1, int tDim = -1, int sDim = -1, int pDim = -1);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by @a itkimage,
   //## a templated itk-image.
   //## Only the header is used, not the data vector! Use
   //## SetVolume(itkimage->GetBufferPointer()) to set the data vector.
   //##
   //## @param tDim override time dimension in @a itkimage (if >0 and <)
   //## @param sDim override z-space dimension in @a itkimage (if >0 and <)
   template <typename itkImageType> void InitializeByItk(const itkImageType* itkimage, int channels = 1, int tDim = -1, int sDim=-1)
   {
     if(itkimage==NULL) return;
 
     MITK_DEBUG << "Initializing MITK image from ITK image.";
     // build array with dimensions in each direction with at least 4 entries
     m_Dimension=itkimage->GetImageDimension();
     unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
     for(i=0;i<m_Dimension;++i)
       tmpDimensions[i]=itkimage->GetLargestPossibleRegion().GetSize().GetSize()[i];
     if(m_Dimension<4)
     {
       unsigned int *p;
       for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
         *p=1;
     }
 
     // overwrite number of slices if sDim is set
     if((m_Dimension>2) && (sDim>=0))
       tmpDimensions[2]=sDim;
     // overwrite number of time points if tDim is set
     if((m_Dimension>3) && (tDim>=0))
       tmpDimensions[3]=tDim;
 
     // rough initialization of Image
    // mitk::PixelType importType = ImportItkPixelType( itkimage::PixelType );
 
 
     Initialize(MakePixelType<itkImageType>(),
       m_Dimension,
       tmpDimensions,
       channels);
     const typename itkImageType::SpacingType & itkspacing = itkimage->GetSpacing();
 
     MITK_DEBUG << "ITK spacing " << itkspacing;
     // access spacing of itk::Image
     Vector3D spacing;
     FillVector3D(spacing, itkspacing[0], 1.0, 1.0);
     if(m_Dimension >= 2)
       spacing[1]=itkspacing[1];
     if(m_Dimension >= 3)
       spacing[2]=itkspacing[2];
 
     // access origin of itk::Image
     Point3D origin;
     const typename itkImageType::PointType & itkorigin = itkimage->GetOrigin();
     MITK_DEBUG << "ITK origin " << itkorigin;
     FillVector3D(origin, itkorigin[0], 0.0, 0.0);
     if(m_Dimension>=2)
       origin[1]=itkorigin[1];
     if(m_Dimension>=3)
       origin[2]=itkorigin[2];
 
     // access direction of itk::Imagm_PixelType = new mitk::PixelType(type);e and include spacing
     const typename itkImageType::DirectionType & itkdirection = itkimage->GetDirection();
     MITK_DEBUG << "ITK direction " << itkdirection;
     mitk::Matrix3D matrix;
     matrix.SetIdentity();
     unsigned int j, itkDimMax3 = (m_Dimension >= 3? 3 : m_Dimension);
     // check if spacing has no zero entry and itkdirection has no zero columns
     bool itkdirectionOk = true;
     mitk::ScalarType columnSum;
     for( j=0; j < itkDimMax3; ++j )
     {
       columnSum = 0.0;
       for ( i=0; i < itkDimMax3; ++i)
       {
         columnSum += fabs(itkdirection[i][j]);
       }
       if(columnSum < mitk::eps)
       {
         itkdirectionOk = false;
       }
       if (    (spacing[j] < - mitk::eps) // (normally sized) negative value
           &&  (j==2) && (m_Dimensions[2] == 1) )
       {
         // Negative spacings can occur when reading single DICOM slices with ITK via GDCMIO
         // In these cases spacing is not determind by ITK correctly (because it distinguishes correctly
         // between slice thickness and inter slice distance -- slice distance is meaningless for
         // single slices).
         // I experienced that ITK produced something meaningful nonetheless because is is
         // evaluating the tag "(0018,0088) Spacing between slices" as a fallback. This tag is not
         // reliable (http://www.itk.org/pipermail/insight-users/2005-September/014711.html)
         // but gives at least a hint.
         // In real world cases I experienced that this tag contained the correct inter slice distance
         // with a negative sign, so we just invert such negative spacings.
         MITK_WARN << "Illegal value of itk::Image::GetSpacing()[" << j <<"]=" << spacing[j] << ". Using inverted value " << -spacing[j];
         spacing[j] = -spacing[j];
       }
       else if (spacing[j] < mitk::eps) // value near zero
       {
         MITK_ERROR << "Illegal value of itk::Image::GetSpacing()[" << j <<"]=" << spacing[j] << ". Using 1.0 instead.";
         spacing[j] = 1.0;
       }
     }
     if(itkdirectionOk == false)
     {
       MITK_ERROR << "Illegal matrix returned by itk::Image::GetDirection():" << itkdirection << " Using identity instead.";
       for ( i=0; i < itkDimMax3; ++i)
         for( j=0; j < itkDimMax3; ++j )
           if ( i == j )
             matrix[i][j] = spacing[j];
           else
             matrix[i][j] = 0.0;
     }
     else
     {
       for ( i=0; i < itkDimMax3; ++i)
         for( j=0; j < itkDimMax3; ++j )
           matrix[i][j] = itkdirection[i][j]*spacing[j];
     }
 
     // re-initialize PlaneGeometry with origin and direction
-    PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(GetSlicedGeometry(0)->GetGeometry2D(0));
+    PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(GetSlicedGeometry(0)->GetPlaneGeometry(0));
     planeGeometry->SetOrigin(origin);
     planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
     // re-initialize SlicedGeometry3D
     SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
     slicedGeometry->InitializeEvenlySpaced(planeGeometry, m_Dimensions[2]);
     slicedGeometry->SetSpacing(spacing);
 
     // re-initialize TimeGeometry
     ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
     timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
     SetTimeGeometry(timeGeometry);
 
     // clean-up
     delete [] tmpDimensions;
 
     this->Initialize();
   };
 
   //##Documentation
   //## @brief Check whether slice @a s at time @a t in channel @a n is valid, i.e.,
   //## is (or can be) inside of the image
   virtual bool IsValidSlice(int s = 0, int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether volume at time @a t in channel @a n is valid, i.e.,
   //## is (or can be) inside of the image
   virtual bool IsValidVolume(int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether the channel @a n is valid, i.e.,
   //## is (or can be) inside of the image
   virtual bool IsValidChannel(int n = 0) const;
 
   //##Documentation
   //## @brief Returns true if an image is rotated, i.e. its geometry's
   //## transformation matrix has nonzero elements besides the diagonal.
   //## Non-diagonal elements are checked if larger then 1/1000 of the matrix' trace.
   bool IsRotated() const;
 
   //##Documentation
   //## @brief Get the sizes of all dimensions as an integer-array.
   //##
   //## @sa GetDimension(int i);
   unsigned int* GetDimensions() const;
 
   ImageDescriptor::Pointer GetImageDescriptor() const
   { return m_ImageDescriptor; }
 
   ChannelDescriptor GetChannelDescriptor( int id = 0 ) const
   { return m_ImageDescriptor->GetChannelDescriptor(id); }
 
   /** \brief Sets a geometry to an image.
     */
   virtual void SetGeometry(BaseGeometry* aGeometry3D);
 
   /**
   * @warning for internal use only
   */
   virtual ImageDataItemPointer GetSliceData(int s = 0, int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   /**
   * @warning for internal use only
   */
   virtual ImageDataItemPointer GetVolumeData(int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   /**
   * @warning for internal use only
   */
   virtual ImageDataItemPointer GetChannelData(int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   /**
   \brief (DEPRECATED) Get the minimum for scalar images
   */
   DEPRECATED (ScalarType GetScalarValueMin(int t=0) const);
 
 
   /**
   \brief (DEPRECATED) Get the maximum for scalar images
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValueMax(int t=0) const);
 
   /**
   \brief (DEPRECATED) Get the second smallest value for scalar images
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMin(int t=0) const);
 
 
   /**
   \brief (DEPRECATED) Get the smallest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValueMinNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the second smallest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMinNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the second largest value for scalar images
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMax(int t=0) const);
 
   /**
   \brief (DEPRECATED) Get the largest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValueMaxNoRecompute( unsigned int t = 0 ) const );
 
   /**
   \brief (DEPRECATED) Get the second largest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMaxNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the smallest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetCountOfMinValuedVoxels(int t = 0) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the largest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetCountOfMaxValuedVoxels(int t = 0) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the largest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (unsigned int GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the smallest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (unsigned int GetCountOfMinValuedVoxelsNoRecompute( unsigned int t = 0 ) const);
 
   /**
     \brief Returns a pointer to the ImageStatisticsHolder object that holds all statistics information for the image.
 
     All Get-methods for statistics properties formerly accessible directly from an Image object are now moved to the
     new \a ImageStatisticsHolder object.
     */
   StatisticsHolderPointer GetStatistics() const
   {
     return m_ImageStatistics;
   }
 
 protected:
 
   mitkCloneMacro(Self);
 
   int GetSliceIndex(int s = 0, int t = 0, int n = 0) const;
 
   int GetVolumeIndex(int t = 0, int n = 0) const;
 
   void ComputeOffsetTable();
 
   virtual bool IsValidTimeStep(int t) const;
 
   virtual void Expand( unsigned int timeSteps );
 
   virtual ImageDataItemPointer AllocateSliceData(int s = 0, int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   virtual ImageDataItemPointer AllocateVolumeData(int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   virtual ImageDataItemPointer AllocateChannelData(int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   Image();
 
   Image(const Image &other);
 
   virtual ~Image();
 
   virtual void Clear();
 
   //## @warning Has to be called by every Initialize method!
   virtual void Initialize();
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
   mutable ImageDataItemPointerArray m_Channels;
   mutable ImageDataItemPointerArray m_Volumes;
   mutable ImageDataItemPointerArray m_Slices;
 
   unsigned int m_Dimension;
 
   unsigned int* m_Dimensions;
 
   ImageDescriptor::Pointer m_ImageDescriptor;
 
   size_t *m_OffsetTable;
   ImageDataItemPointer m_CompleteData;
 
   // Image statistics Holder replaces the former implementation directly inside this class
   friend class ImageStatisticsHolder;
   StatisticsHolderPointer m_ImageStatistics;
 
 private:
 
   /** Stores all existing ImageReadAccessors */
   std::vector<ImageAccessorBase*> m_Readers;
   /** Stores all existing ImageWriteAccessors */
   std::vector<ImageAccessorBase*> m_Writers;
   /** Stores all existing ImageVtkAccessors */
   std::vector<ImageAccessorBase*> m_VtkReaders;
 
   /** A mutex, which needs to be locked to manage m_Readers and m_Writers */
   itk::SimpleFastMutexLock m_ReadWriteLock;
   /** A mutex, which needs to be locked to manage m_VtkReaders */
   itk::SimpleFastMutexLock m_VtkReadersLock;
 
 };
 
  /**
  * @brief Equal A function comparing two images for beeing equal in meta- and imagedata
  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::Image& i1, const mitk::Image& i2) instead.
  *
  * @ingroup MITKTestingAPI
  *
  * Following aspects are tested for equality:
  *  - dimension of the images
  *  - size of the images
  *  - pixel type
  *  - pixel values : pixel values are expected to be identical at each position ( for other options see mitk::CompareImageFilter )
  *
  * @param rightHandSide An image to be compared
  * @param leftHandSide An image to be compared
  * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
  * @param verbose Flag indicating if the user wants detailed console output or not.
  * @return true, if all subsequent comparisons are true, false otherwise
  */
 DEPRECATED (MITK_CORE_EXPORT bool Equal( const mitk::Image* leftHandSide, const mitk::Image* rightHandSide, ScalarType eps, bool verbose ));
 
 /**
 * @brief Equal A function comparing two images for beeing equal in meta- and imagedata
 *
 * @ingroup MITKTestingAPI
 *
 * Following aspects are tested for equality:
 *  - dimension of the images
 *  - size of the images
 *  - pixel type
 *  - pixel values : pixel values are expected to be identical at each position ( for other options see mitk::CompareImageFilter )
 *
 * @param rightHandSide An image to be compared
 * @param leftHandSide An image to be compared
 * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
 * @param verbose Flag indicating if the user wants detailed console output or not.
 * @return true, if all subsequent comparisons are true, false otherwise
 */
 MITK_CORE_EXPORT bool Equal( const mitk::Image& leftHandSide, const mitk::Image& rightHandSide, ScalarType eps, bool verbose );
 
 
 
 
 //}
 //##Documentation
 //## @brief Cast an itk::Image (with a specific type) to an mitk::Image.
 //##
 //## CastToMitkImage does not cast pixel types etc., just image data
 //## Needs "mitkImage.h" header included.
 //## If you get a compile error, try image.GetPointer();
 //## @ingroup Adaptor
 //## \sa mitkITKImageImport
 template <typename ItkOutputImageType>
 void CastToMitkImage(const itk::SmartPointer<ItkOutputImageType>& itkimage, itk::SmartPointer<mitk::Image>& mitkoutputimage)
 {
   if(mitkoutputimage.IsNull())
   {
     mitkoutputimage = mitk::Image::New();
   }
   mitkoutputimage->InitializeByItk(itkimage.GetPointer());
   mitkoutputimage->SetChannel(itkimage->GetBufferPointer());
 }
 
 //##Documentation
 //## @brief Cast an itk::Image (with a specific type) to an mitk::Image.
 //##
 //## CastToMitkImage does not cast pixel types etc., just image data
 //## Needs "mitkImage.h" header included.
 //## If you get a compile error, try image.GetPointer();
 //## @ingroup Adaptor
 //## \sa mitkITKImageImport
 template <typename ItkOutputImageType>
 void CastToMitkImage(const ItkOutputImageType* itkimage, itk::SmartPointer<mitk::Image>& mitkoutputimage)
 {
   if(mitkoutputimage.IsNull())
   {
     mitkoutputimage = mitk::Image::New();
   }
   mitkoutputimage->InitializeByItk(itkimage);
   mitkoutputimage->SetChannel(itkimage->GetBufferPointer());
 }
 } // namespace mitk
 
 #endif /* MITKIMAGE_H_HEADER_INCLUDED_C1C2FCD2 */
diff --git a/Core/Code/DataManagement/mitkMatrixConvert.h b/Core/Code/DataManagement/mitkMatrixConvert.h
index 3b5428d6a6..41410397f9 100644
--- a/Core/Code/DataManagement/mitkMatrixConvert.h
+++ b/Core/Code/DataManagement/mitkMatrixConvert.h
@@ -1,152 +1,151 @@
 /*===================================================================
 
 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 MITKMATRIXCONVERT_H_HEADER_INCLUDED_C1EBD0AD
 #define MITKMATRIXCONVERT_H_HEADER_INCLUDED_C1EBD0AD
 
-#include "mitkGeometry3D.h"
 #include "mitkBaseGeometry.h"
 #include "mitkItkMatrixHack.h"
 #include <vtkMatrix4x4.h>
 
 namespace mitk
 {
   template <class TTransformType>
   void TransferVtkMatrixToItkTransform(const vtkMatrix4x4* vtkmatrix, TTransformType * itkTransform)
   {
   if(itkTransform==NULL)
     return;
 
   typename TTransformType::MatrixType::InternalMatrixType& vnlMatrix =
     const_cast<typename TTransformType::MatrixType::InternalMatrixType&>(itkTransform->GetMatrix().GetVnlMatrix());
 
   for ( int i=0; i < 3; ++i)
     for( int j=0; j < 3; ++j )
       vnlMatrix[i][j] = vtkmatrix->GetElement( i, j );
   // *This* ensures m_MatrixMTime.Modified(), which is therewith not equal to
   // m_InverseMatrixMTime, thus a new inverse will be calculated (when
   // requested).
   static_cast<mitk::ItkMatrixHack<TTransformType>*>(itkTransform)->MatrixChanged();
 
   typename TTransformType::OffsetType offset;
   offset[0] = vtkmatrix->GetElement( 0, 3 );
   offset[1] = vtkmatrix->GetElement( 1, 3 );
   offset[2] = vtkmatrix->GetElement( 2, 3 );
   itkTransform->SetOffset( offset );
   }
 
   template <class TTransformType>
   void TransferItkTransformToVtkMatrix(const TTransformType * itkTransform, vtkMatrix4x4* vtkmatrix)
   {
     int i,j;
     for(i=0;i<3;++i)
       for(j=0;j<3;++j)
         vtkmatrix->SetElement(i, j, itkTransform->GetMatrix().GetVnlMatrix().get(i, j));
     for(i=0;i<3;++i)
       vtkmatrix->SetElement(i, 3, itkTransform->GetOffset()[i]);
     for(i=0;i<3;++i)
       vtkmatrix->SetElement(3, i, 0.0);
     vtkmatrix->SetElement(3, 3, 1);
   }
 
   template <class TTransformType1, class TTransformType2>
   void ConvertItkTransform(const TTransformType1* sourceTransform, TTransformType2* destTransform)
   {
     if((sourceTransform==NULL) || (destTransform==NULL))
       return;
 
     // transfer offset
     const typename TTransformType1::OutputVectorType& sourceOffset =
       sourceTransform->GetOffset();
 
     typename TTransformType2::OutputVectorType offset;
     offset[0] = sourceOffset[0]; offset[1] = sourceOffset[1]; offset[2] = sourceOffset[2];
     destTransform->SetOffset( offset );
 
     typename TTransformType1::MatrixType::InternalMatrixType& sourceVnlMatrix =
       const_cast<typename TTransformType1::MatrixType::InternalMatrixType&>(sourceTransform->GetMatrix().GetVnlMatrix());
 
     //transfer matrix
     typename TTransformType2::MatrixType::InternalMatrixType& destVnlMatrix =
       const_cast<typename TTransformType2::MatrixType::InternalMatrixType&>(destTransform->GetMatrix().GetVnlMatrix());
 
     for ( int i=0; i < 3; ++i)
       for( int j=0; j < 3; ++j )
         destVnlMatrix[i][j] = sourceVnlMatrix[i][j];
 
     // *This* ensures m_MatrixMTime.Modified(), which is therewith not equal to
     // m_InverseMatrixMTime, thus a new inverse will be calculated (when
     // requested).
     static_cast<mitk::ItkMatrixHack<TTransformType2>*>(destTransform)->MatrixChanged();
   }
 
   template <class TMatrixType>
   void GetRotation(const mitk::BaseGeometry * geometry, TMatrixType& itkmatrix)
   {
     const mitk::Vector3D& spacing = geometry->GetSpacing();
     typename mitk::BaseGeometry::TransformType::MatrixType::InternalMatrixType& geometryVnlMatrix =
       const_cast<typename mitk::BaseGeometry::TransformType::MatrixType::InternalMatrixType&>(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix());
 
     typename TMatrixType::InternalMatrixType& outputVnlMatrix =
       const_cast<typename TMatrixType::InternalMatrixType&>(itkmatrix.GetVnlMatrix());
 
     for ( int i=0; i < 3; ++i)
       for( int j=0; j < 3; ++j )
         outputVnlMatrix [i][j] = geometryVnlMatrix [i][j] / spacing[j];
   }
 
   template <class TTransformType>
   void GetWorldToItkPhysicalTransform(const mitk::BaseGeometry * geometry, TTransformType* itkTransform)
   {
     if(itkTransform==NULL)
       return;
 
     // get rotation matrix and offset from Geometry and transfer in TTransformType types
     typename TTransformType::MatrixType rotationMatrix;
     GetRotation(geometry, rotationMatrix);
 
     const typename mitk::Geometry3D::TransformType::OffsetType& geometryOffset =
       geometry->GetIndexToWorldTransform()->GetOffset();
 
     vnl_vector<typename TTransformType::MatrixType::ValueType> vnlOffset(3);
     vnlOffset[0] = geometryOffset[0]; vnlOffset[1] = geometryOffset[1]; vnlOffset[2] = geometryOffset[2];
 
     // do calculations
     typename TTransformType::MatrixType::InternalMatrixType inverseRotationVnlMatrix = rotationMatrix.GetTranspose();
 
     vnlOffset -= inverseRotationVnlMatrix*vnlOffset;
 
     typename TTransformType::OutputVectorType offset;//vnl_vector<TTransformType::MatrixType::ValueType> offset;
     offset[0] = vnlOffset[0]; offset[1] = vnlOffset[1]; offset[2] = vnlOffset[2];
     itkTransform->SetOffset( offset );
 
     // copy in destination itkTransform
     typename TTransformType::MatrixType::InternalMatrixType& destVnlMatrix =
       const_cast<typename TTransformType::MatrixType::InternalMatrixType&>(itkTransform->GetMatrix().GetVnlMatrix());
 
     for ( int i=0; i < 3; ++i)
       for( int j=0; j < 3; ++j )
         destVnlMatrix[i][j] = inverseRotationVnlMatrix[i][j];
     // *This* ensures m_MatrixMTime.Modified(), which is therewith not equal to
     // m_InverseMatrixMTime, thus a new inverse will be calculated (when
     // requested).
     static_cast<mitk::ItkMatrixHack<TTransformType>*>(itkTransform)->MatrixChanged();
   }
 
 }
 
 #endif /* MITKMATRIXCONVERT_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkPlaneGeometry.h b/Core/Code/DataManagement/mitkPlaneGeometry.h
index abf20b60c4..384b0f5e89 100644
--- a/Core/Code/DataManagement/mitkPlaneGeometry.h
+++ b/Core/Code/DataManagement/mitkPlaneGeometry.h
@@ -1,566 +1,564 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
-
-  /**
-  * \brief Describes the geometry of a plane object
-  *
-  * Describes a two-dimensional manifold, i.e., to put it simply,
-  * an object that can be described using a 2D coordinate-system.
-  *
-  * PlaneGeometry can map points between 3D world coordinates
-  * (in mm) and the described 2D coordinate-system (in mm) by first projecting
-  * the 3D point onto the 2D manifold and then calculating the 2D-coordinates
-  * (in mm). These 2D-mm-coordinates can be further converted into
-  * 2D-unit-coordinates (e.g., pixels), giving a parameter representation of
-  * the object with parameter values inside a rectangle
-  * (e.g., [0,0]..[width, height]), which is the bounding box (bounding range
-  * in z-direction always [0]..[1]).
-  *
-  * A PlaneGeometry describes the 2D representation within a 3D object and is
-  * therefore itself a Geometry3D (derived from BaseGeometry). For example,
-  * a single CT-image (slice) is 2D in the sense that you can access the
-  * pixels using 2D-coordinates, but is also 3D, as the pixels are really
-  * voxels, thus have an extension (thickness) in the 3rd dimension.
-  *
-  *
-  * Optionally, a reference BaseGeometry can be specified, which usually would
-  * be the geometry associated with the underlying dataset. This is currently
-  * used for calculating the intersection of inclined / rotated planes
-  * (represented as PlaneGeometry) with the bounding box of the associated
-  * BaseGeometry.
-  *
-  * \warning The PlaneGeometry are not necessarily up-to-date and not even
-  * initialized. As described in the previous paragraph, one of the
-  * Generate-/Copy-/UpdateOutputInformation methods have to initialize it.
-  * mitk::BaseData::GetGeometry2D() makes sure, that the PlaneGeometry is
-  * up-to-date before returning it (by setting the update extent appropriately
-  * and calling UpdateOutputInformation).
-  *
-  * Rule: everything is in mm (or ms for temporal information) if not
-  * stated otherwise.
-  * \ingroup Geometry
-  */
+/**
+* \brief Describes the geometry of a plane object
+*
+* Describes a two-dimensional manifold, i.e., to put it simply,
+* an object that can be described using a 2D coordinate-system.
+*
+* PlaneGeometry can map points between 3D world coordinates
+* (in mm) and the described 2D coordinate-system (in mm) by first projecting
+* the 3D point onto the 2D manifold and then calculating the 2D-coordinates
+* (in mm). These 2D-mm-coordinates can be further converted into
+* 2D-unit-coordinates (e.g., pixels), giving a parameter representation of
+* the object with parameter values inside a rectangle
+* (e.g., [0,0]..[width, height]), which is the bounding box (bounding range
+* in z-direction always [0]..[1]).
+*
+* A PlaneGeometry describes the 2D representation within a 3D object (derived from BaseGeometry). For example,
+* a single CT-image (slice) is 2D in the sense that you can access the
+* pixels using 2D-coordinates, but is also 3D, as the pixels are really
+* voxels, thus have an extension (thickness) in the 3rd dimension.
+*
+*
+* Optionally, a reference BaseGeometry can be specified, which usually would
+* be the geometry associated with the underlying dataset. This is currently
+* used for calculating the intersection of inclined / rotated planes
+* (represented as PlaneGeometry) with the bounding box of the associated
+* BaseGeometry.
+*
+* \warning The PlaneGeometry are not necessarily up-to-date and not even
+* initialized. As described in the previous paragraph, one of the
+* Generate-/Copy-/UpdateOutputInformation methods have to initialize it.
+* mitk::BaseData::GetPlaneGeometry() makes sure, that the PlaneGeometry is
+* up-to-date before returning it (by setting the update extent appropriately
+* and calling UpdateOutputInformation).
+*
+* Rule: everything is in mm (or ms for temporal information) if not
+* stated otherwise.
+* \ingroup Geometry
+*/
 
 #ifndef PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 #define PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 
 #include <MitkCoreExports.h>
 #include "mitkBaseGeometry.h"
 #include "mitkRestorePlanePositionOperation.h"
 
 #include <vnl/vnl_cross.h>
 
 namespace mitk {
   template < class TCoordRep, unsigned int NPointDimension > class Line;
   typedef Line<ScalarType, 3> Line3D;
 
   /**
   * \brief Describes a two-dimensional, rectangular plane
   *
   * \ingroup Geometry
   */
   class MITK_CORE_EXPORT PlaneGeometry : public BaseGeometry
   {
   public:
     mitkClassMacro(PlaneGeometry,BaseGeometry);
 
     /** Method for creation through the object factory. */
-  itkFactorylessNewMacro(Self)
-  itkCloneMacro(Self)
+    itkFactorylessNewMacro(Self)
+      itkCloneMacro(Self)
 
-    enum PlaneOrientation
+      enum PlaneOrientation
     {
-    Axial,
+      Axial,
       Sagittal,
       Frontal
     };
 
     virtual void IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const;
 
     virtual void WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void IndexToWorld(const mitk::Point2D &atPt2d_untis, const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
     /**
     * \brief Initialize a plane with orientation \a planeorientation
     * (default: axial) with respect to \a BaseGeometry (default: identity).
-    * Spacing also taken from \a geometry3D.
+    * Spacing also taken from \a BaseGeometry.
     *
     * \warning A former version of this method created a geometry with unit
     * spacing. For unit spacing use
     *
     * \code
     *   // for in-plane unit spacing:
     *   thisgeometry->SetSizeInUnits(thisgeometry->GetExtentInMM(0),
     *     thisgeometry->GetExtentInMM(1));
     *   // additionally, for unit spacing in normal direction (former version
     *   // did not do this):
     *   thisgeometry->SetExtentInMM(2, 1.0);
     * \endcode
     */
     virtual void InitializeStandardPlane( const BaseGeometry* geometry3D,
       PlaneOrientation planeorientation = Axial, ScalarType zPosition = 0,
       bool frontside=true, bool rotated=false );
 
     /**
     * \brief Initialize a plane with orientation \a planeorientation
     * (default: axial) with respect to \a BaseGeometry (default: identity).
     * Spacing also taken from \a BaseGeometry.
     *
     * \param top if \a true, create plane at top, otherwise at bottom
     * (for PlaneOrientation Axial, for other plane locations respectively)
     */
     virtual void InitializeStandardPlane( const BaseGeometry* geometry3D, bool top,
       PlaneOrientation planeorientation = Axial,
       bool frontside=true, bool rotated=false );
 
     /**
     * \brief Initialize a plane with orientation \a planeorientation
     * (default: axial) with respect to \a transform (default: identity)
     * given width and height in units.
     *
     */
     virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
       const AffineTransform3D* transform = NULL,
       PlaneOrientation planeorientation = Axial,
       ScalarType zPosition = 0, bool frontside=true, bool rotated=false );
 
     /**
     * \brief Initialize plane with orientation \a planeorientation
     * (default: axial) given width, height and spacing.
     *
     */
     virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
       const Vector3D & spacing, PlaneOrientation planeorientation = Axial,
       ScalarType zPosition = 0, bool frontside = true, bool rotated = false );
 
     /**
     * \brief Initialize plane by width and height in pixels, right-/down-vector
     * (itk) to describe orientation in world-space (vectors will be normalized)
     * and spacing (default: 1.0 mm in all directions).
     *
     * The vectors are normalized and multiplied by the respective spacing before
     * they are set in the matrix.
     */
     virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
       const Vector3D& rightVector, const Vector3D& downVector,
       const Vector3D *spacing = NULL );
 
     /**
     * \brief Initialize plane by width and height in pixels,
     * right-/down-vector (vnl) to describe orientation in world-space (vectors
     * will be normalized) and spacing (default: 1.0 mm in all directions).
     *
     * The vectors are normalized and multiplied by the respective spacing
     * before they are set in the matrix.
     */
     virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
       const VnlVector& rightVector, const VnlVector& downVector,
       const Vector3D * spacing = NULL );
 
     /**
     * \brief Initialize plane by right-/down-vector (itk) and spacing
     * (default: 1.0 mm in all directions).
     *
     * The length of the right-/-down-vector is used as width/height in units,
     * respectively. Then, the vectors are normalized and multiplied by the
     * respective spacing before they are set in the matrix.
     */
     virtual void InitializeStandardPlane( const Vector3D& rightVector,
       const Vector3D& downVector, const Vector3D * spacing = NULL );
 
     /**
     * \brief Initialize plane by right-/down-vector (vnl) and spacing
     * (default: 1.0 mm in all directions).
     *
     * The length of the right-/-down-vector is used as width/height in units,
     * respectively. Then, the vectors are normalized and multiplied by the
     * respective spacing before they are set in the matrix.
     */
     virtual void InitializeStandardPlane( const VnlVector& rightVector,
       const VnlVector& downVector, const Vector3D * spacing = NULL );
 
     /**
     * \brief Initialize plane by origin and normal (size is 1.0 mm in
     * all directions, direction of right-/down-vector valid but
     * undefined).
     *
     */
     virtual void InitializePlane( const Point3D& origin, const Vector3D& normal);
 
     /**
     * \brief Initialize plane by right-/down-vector.
     *
     * \warning The vectors are set into the matrix as they are,
     * \em without normalization!
     */
     void SetMatrixByVectors( const VnlVector& rightVector,
       const VnlVector& downVector, ScalarType thickness=1.0 );
 
     /**
     * \brief Change \a transform so that the third column of the
     * transform-martix is perpendicular to the first two columns
     *
     */
     static void EnsurePerpendicularNormal( AffineTransform3D* transform );
 
     /**
     * \brief Normal of the plane
     *
     */
     Vector3D GetNormal() const;
 
     /**
     * \brief Normal of the plane as VnlVector
     *
     */
     VnlVector GetNormalVnl() const;
 
     virtual ScalarType SignedDistance( const Point3D& pt3d_mm ) const;
 
     /**
     * \brief Calculates, whether a point is below or above the plane. There are two different
     *calculation methods, with or without consideration of the bounding box.
     */
     virtual bool IsAbove( const Point3D& pt3d_mm , bool considerBoundingBox=false) const;
 
     /**
     * \brief Distance of the point from the plane
     * (bounding-box \em not considered)
     *
     */
     ScalarType DistanceFromPlane( const Point3D& pt3d_mm ) const ;
 
     /**
     * \brief Signed distance of the point from the plane
     * (bounding-box \em not considered)
     *
     * > 0 : point is in the direction of the direction vector.
     */
     inline ScalarType SignedDistanceFromPlane( const Point3D& pt3d_mm ) const
     {
       ScalarType len = GetNormalVnl().two_norm();
 
       if( len == 0 )
         return 0;
 
       return (pt3d_mm-GetOrigin())*GetNormal() / len;
     }
 
     /**
     * \brief Distance of the plane from another plane
     * (bounding-box \em not considered)
     *
     * Result is 0 if planes are not parallel.
     */
     ScalarType DistanceFromPlane(const PlaneGeometry* plane) const
     {
       return fabs(SignedDistanceFromPlane(plane));
     }
 
     /**
     * \brief Signed distance of the plane from another plane
     * (bounding-box \em not considered)
     *
     * Result is 0 if planes are not parallel.
     */
     inline ScalarType SignedDistanceFromPlane( const PlaneGeometry *plane ) const
     {
       if(IsParallel(plane))
       {
         return SignedDistance(plane->GetOrigin());
       }
       return 0;
     }
 
     /**
     * \brief Calculate the intersecting line of two planes
     *
     * \return \a true planes are intersecting
     * \return \a false planes do not intersect
     */
     bool IntersectionLine( const PlaneGeometry *plane, Line3D &crossline ) const;
 
     /**
     * \brief Calculate two points where another plane intersects the border of this plane
     *
     * \return number of intersection points (0..2). First interection point (if existing)
     * is returned in \a lineFrom, second in \a lineTo.
     */
     unsigned int IntersectWithPlane2D(const PlaneGeometry *plane,
       Point2D &lineFrom, Point2D &lineTo ) const ;
 
     /**
     * \brief Calculate the angle between two planes
     *
     * \return angle in radiants
     */
     double Angle( const PlaneGeometry *plane ) const;
 
     /**
     * \brief Calculate the angle between the plane and a line
     *
     * \return angle in radiants
     */
     double Angle( const Line3D &line ) const;
 
     /**
     * \brief Calculate intersection point between the plane and a line
     *
     * \param intersectionPoint intersection point
     * \return \a true if \em unique intersection exists, i.e., if line
     * is \em not on or parallel to the plane
     */
     bool IntersectionPoint( const Line3D &line,
       Point3D &intersectionPoint ) const;
 
     /**
     * \brief Calculate line parameter of intersection point between the
     * plane and a line
     *
     * \param t parameter of line: intersection point is
     * line.GetPoint()+t*line.GetDirection()
     * \return \a true if \em unique intersection exists, i.e., if line
     * is \em not on or parallel to the plane
     */
     bool IntersectionPointParam( const Line3D &line, double &t ) const;
 
     /**
     * \brief Returns whether the plane is parallel to another plane
     *
     * @return true iff the normal vectors both point to the same or exactly oposit direction
     */
     bool IsParallel( const PlaneGeometry *plane ) const;
 
     /**
     * \brief Returns whether the point is on the plane
     * (bounding-box \em not considered)
     */
     bool IsOnPlane( const Point3D &point ) const;
 
     /**
     * \brief Returns whether the line is on the plane
     * (bounding-box \em not considered)
     */
     bool IsOnPlane( const Line3D &line ) const;
 
     /**
     * \brief Returns whether the plane is on the plane
     * (bounding-box \em not considered)
     *
     * @return true iff the normal vector of the planes point to the same or the exactly oposit direction and
     *  the distance of the planes is < eps
     *
     */
     bool IsOnPlane( const PlaneGeometry *plane ) const;
 
     /**
     * \brief Returns the lot from the point to the plane
     */
     Point3D ProjectPointOntoPlane( const Point3D &pt ) const;
 
     virtual itk::LightObject::Pointer InternalClone() const;
 
     /** Implements operation to re-orient the plane */
     virtual void ExecuteOperation( Operation *operation );
 
-        /**
+    /**
     * \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
     * geometry. The result is a 2D point in mm (\a pt2d_mm).
     *
     * The result is a 2D point in mm (\a pt2d_mm) relative to the upper-left
     * corner of the geometry. To convert this point into units (e.g., pixels
     * in case of an image), use WorldToIndex.
     * \return true projection was possible
     * \sa Project(const mitk::Point3D &pt3d_mm, mitk::Point3D
     * &projectedPt3d_mm)
     */
     virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
 
     /**
     * \brief Converts a 2D point given in mm (\a pt2d_mm) relative to the
     * upper-left corner of the geometry into the corresponding
     * world-coordinate (a 3D point in mm, \a pt3d_mm).
     *
     * To convert a 2D point given in units (e.g., pixels in case of an
     * image) into a 2D point given in mm (as required by this method), use
     * IndexToWorld.
     */
     virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
 
-        /**
+    /**
     * \brief Set the width and height of this 2D-geometry in units by calling
     * SetBounds. This does \a not change the extent in mm!
     *
     * For an image, this is the number of pixels in x-/y-direction.
     * \note In contrast to calling SetBounds directly, this does \a not change
     * the extent in mm!
     */
     virtual void SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height);
 
     /**
     * \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
     * geometry. The result is a 3D point in mm (\a projectedPt3d_mm).
     *
     * \return true projection was possible
     */
     virtual bool Project(const mitk::Point3D &pt3d_mm,
       mitk::Point3D &projectedPt3d_mm) const;
 
     /**
     * \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
     * geometry. The result is a 2D vector in mm (\a vec2d_mm).
     *
     * The result is a 2D vector in mm (\a vec2d_mm) relative to the
     * upper-left
     * corner of the geometry. To convert this point into units (e.g., pixels
     * in case of an image), use WorldToIndex.
     * \return true projection was possible
     * \sa Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D
     * &projectedVec3d_mm)
     */
     virtual bool Map(const mitk::Point3D & atPt3d_mm,
       const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
 
     /**
     * \brief Converts a 2D vector given in mm (\a vec2d_mm) relative to the
     * upper-left corner of the geometry into the corresponding
     * world-coordinate (a 3D vector in mm, \a vec3d_mm).
     *
     * To convert a 2D vector given in units (e.g., pixels in case of an
     * image) into a 2D vector given in mm (as required by this method), use
     * IndexToWorld.
     */
     virtual void Map(const mitk::Point2D & atPt2d_mm,
       const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
 
     /**
     * \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
     * geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
     *
     * DEPRECATED. Use Project(vector,vector) instead
     *
     * \return true projection was possible
     */
     virtual bool Project(const mitk::Point3D & atPt3d_mm,
       const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
 
     /**
     * \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
     * geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
     *
     * \return true projection was possible
     */
     virtual bool Project( const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
 
     /**
     * \brief Distance of the point from the geometry
     * (bounding-box \em not considered)
     *
     */
     inline ScalarType Distance(const Point3D& pt3d_mm) const
     {
       return fabs(SignedDistance(pt3d_mm));
     }
 
-        /**
+    /**
     * \brief Set the geometrical frame of reference in which this PlaneGeometry
     * is placed.
     *
-    * This would usually be the Geometry3D of the underlying dataset, but
+    * This would usually be the BaseGeometry of the underlying dataset, but
     * setting it is optional.
     */
     void SetReferenceGeometry( mitk::BaseGeometry *geometry );
 
     /**
     * \brief Get the geometrical frame of reference for this PlaneGeometry.
     */
     BaseGeometry *GetReferenceGeometry() const;
     bool HasReferenceGeometry() const;
 
-
   protected:
     PlaneGeometry();
 
     PlaneGeometry(const PlaneGeometry& other);
 
     virtual ~PlaneGeometry();
 
     virtual void PrintSelf( std::ostream &os, itk::Indent indent ) const;
 
-    virtual void PreSetBounds( const BoundingBox::BoundsArrayType &bounds );
-
-    virtual void PreSetIndexToWorldTransform( AffineTransform3D *transform);
-
-    virtual void PostSetExtentInMM(int direction, ScalarType extentInMM);
-
-    virtual void PostSetIndexToWorldTransform(mitk::AffineTransform3D* transform);
-
     /**
     * \brief factor to convert x-coordinates from mm to units and vice versa
     *
     */
     mutable mitk::ScalarType m_ScaleFactorMMPerUnitX;
 
     /**
     * \brief factor to convert y-coordinates from mm to units and vice versa
     *
     */
     mutable mitk::ScalarType m_ScaleFactorMMPerUnitY;
 
     mitk::BaseGeometry *m_ReferenceGeometry;
 
   private:
+
+    virtual void PreSetBounds( const BoundingBox::BoundsArrayType &bounds );
+
+    virtual void PreSetIndexToWorldTransform( AffineTransform3D *transform);
+
+    virtual void PostSetExtentInMM(int direction, ScalarType extentInMM);
+
+    virtual void PostSetIndexToWorldTransform(mitk::AffineTransform3D* transform);
+
     /**
     * \brief Compares plane with another plane: \a true if IsOnPlane
     * (bounding-box \em not considered)
     */
     virtual bool operator==( const PlaneGeometry * ) const { return false; };
 
     /**
     * \brief Compares plane with another plane: \a false if IsOnPlane
     * (bounding-box \em not considered)
     */
     virtual bool operator!=( const PlaneGeometry * ) const { return false; };
   };
 } // namespace mitk
 
 #endif /* PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/mitkGeometry2DData.cpp b/Core/Code/DataManagement/mitkPlaneGeometryData.cpp
similarity index 56%
rename from Core/Code/DataManagement/mitkGeometry2DData.cpp
rename to Core/Code/DataManagement/mitkPlaneGeometryData.cpp
index 6e7b6e9e20..a100f2b4c7 100644
--- a/Core/Code/DataManagement/mitkGeometry2DData.cpp
+++ b/Core/Code/DataManagement/mitkPlaneGeometryData.cpp
@@ -1,87 +1,87 @@
 /*===================================================================
 
 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 "mitkGeometry2DData.h"
+#include "mitkPlaneGeometryData.h"
 #include "mitkBaseProcess.h"
 #include <mitkProportionalTimeGeometry.h>
 
-mitk::Geometry2DData::Geometry2DData()
+mitk::PlaneGeometryData::PlaneGeometryData()
 {
 }
 
-mitk::Geometry2DData::~Geometry2DData()
+mitk::PlaneGeometryData::~PlaneGeometryData()
 {
 }
 
-void mitk::Geometry2DData::SetGeometry(mitk::BaseGeometry *geometry)
+void mitk::PlaneGeometryData::SetGeometry(mitk::BaseGeometry *geometry)
 {
   if(geometry==NULL)
-    SetGeometry2D(NULL);
+    SetPlaneGeometry(NULL);
   else
   {
     PlaneGeometry* geometry2d = dynamic_cast<PlaneGeometry*>(geometry);
     if(geometry2d==NULL)
-      itkExceptionMacro(<<"Trying to set a geometry which is not a PlaneGeometry into Geometry2DData.");
-    SetGeometry2D(geometry2d);
+      itkExceptionMacro(<<"Trying to set a geometry which is not a PlaneGeometry into PlaneGeometryData.");
+    SetPlaneGeometry(geometry2d);
   }
 }
 
-void mitk::Geometry2DData::SetGeometry2D(mitk::PlaneGeometry *geometry2d)
+void mitk::PlaneGeometryData::SetPlaneGeometry(mitk::PlaneGeometry *geometry2d)
 {
   if(geometry2d != NULL)
   {
     ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
     timeGeometry->Initialize(geometry2d, 1);
     SetTimeGeometry(timeGeometry);
     Modified();
   }
   else
     Superclass::SetGeometry(geometry2d);
 }
 
-void mitk::Geometry2DData::UpdateOutputInformation()
+void mitk::PlaneGeometryData::UpdateOutputInformation()
 {
   Superclass::UpdateOutputInformation();
 }
 
-void mitk::Geometry2DData::SetRequestedRegionToLargestPossibleRegion()
+void mitk::PlaneGeometryData::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 
-bool mitk::Geometry2DData::RequestedRegionIsOutsideOfTheBufferedRegion()
+bool mitk::PlaneGeometryData::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
-  if(GetGeometry2D()==NULL) return true;
+  if(GetPlaneGeometry()==NULL) return true;
 
   return false;
 }
 
-bool mitk::Geometry2DData::VerifyRequestedRegion()
+bool mitk::PlaneGeometryData::VerifyRequestedRegion()
 {
-  if(GetGeometry2D()==NULL) return false;
+  if(GetPlaneGeometry()==NULL) return false;
 
   return true;
 }
 
-void mitk::Geometry2DData::SetRequestedRegion( const itk::DataObject *)
+void mitk::PlaneGeometryData::SetRequestedRegion( const itk::DataObject *)
 {
 
 }
 
-void mitk::Geometry2DData::CopyInformation(const itk::DataObject *)
+void mitk::PlaneGeometryData::CopyInformation(const itk::DataObject *)
 {
 }
diff --git a/Core/Code/DataManagement/mitkGeometry2DData.h b/Core/Code/DataManagement/mitkPlaneGeometryData.h
similarity index 86%
rename from Core/Code/DataManagement/mitkGeometry2DData.h
rename to Core/Code/DataManagement/mitkPlaneGeometryData.h
index 1ff003c1b6..cbac12f09c 100644
--- a/Core/Code/DataManagement/mitkGeometry2DData.h
+++ b/Core/Code/DataManagement/mitkPlaneGeometryData.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 MITKGEOMETRY2DDATA_H_HEADER_INCLUDED_C19C01E2
 #define MITKGEOMETRY2DDATA_H_HEADER_INCLUDED_C19C01E2
 
 #include <MitkCoreExports.h>
 #include "mitkBaseData.h"
 #include "mitkGeometryData.h"
 #include "mitkPlaneGeometry.h"
 
 namespace mitk {
 
 //##Documentation
 //## @brief Data class containing PlaneGeometry objects
 //## @ingroup Geometry
 //##
-class MITK_CORE_EXPORT Geometry2DData : public GeometryData
+class MITK_CORE_EXPORT PlaneGeometryData : public GeometryData
 {
 public:
-  mitkClassMacro(Geometry2DData, GeometryData);
+  mitkClassMacro(PlaneGeometryData, GeometryData);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   //##Documentation
   //## @brief Set the reference to a PlaneGeometry that is stored
   //## by the object
   //##
   //## @warning Accepts only instances of PlaneGeometry or sub-classes.
   virtual void SetGeometry(mitk::BaseGeometry *geometry);
 
   //##Documentation
   //## @brief Set the reference to the PlaneGeometry that is stored
   //## by the object
-  virtual void SetGeometry2D(mitk::PlaneGeometry* geometry2d);
+  virtual void SetPlaneGeometry(mitk::PlaneGeometry* geometry2d);
   //##Documentation
   //## @brief Get the reference to the PlaneGeometry that is stored
   //## by the object
-  virtual mitk::PlaneGeometry * GetGeometry2D() const
+  virtual mitk::PlaneGeometry * GetPlaneGeometry() const
   {
     return static_cast<mitk::PlaneGeometry *>(GetGeometry());
   };
 
   virtual void UpdateOutputInformation();
 
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   virtual bool VerifyRequestedRegion();
 
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
   virtual void CopyInformation(const itk::DataObject *data);
 
 protected:
-  Geometry2DData();
+  PlaneGeometryData();
 
-  virtual ~Geometry2DData();
+  virtual ~PlaneGeometryData();
 };
 
 } // namespace mitk
 #endif /* MITKGEOMETRY2DDATA_H_HEADER_INCLUDED_C19C01E2 */
diff --git a/Core/Code/DataManagement/mitkPlaneOrientationProperty.h b/Core/Code/DataManagement/mitkPlaneOrientationProperty.h
index 9496f984d9..76507ca0c0 100644
--- a/Core/Code/DataManagement/mitkPlaneOrientationProperty.h
+++ b/Core/Code/DataManagement/mitkPlaneOrientationProperty.h
@@ -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.
 
 ===================================================================*/
 
 #ifndef MITK_PLANE_DECORATION_PROPERTY__H
 #define MITK_PLANE_DECORATION_PROPERTY__H
 
 #include "mitkEnumerationProperty.h"
 
 namespace mitk
 {
 
 #ifdef _MSC_VER
 # pragma warning(push)
 # pragma warning(disable: 4522)
 #endif
 
 /**
  * Property which controls whether 2D line representation of a PlaneGeometry
  * should have small arrows at both ends to indicate the orientation of
  * the plane, and whether the arrows should be oriented in the direction of
  * the plane's normal or against it.
  *
  * Valid values of the enumeration property are
  * - PLANE_DECORATION_NONE (no arrows)
  * - PLANE_DECORATION_POSITIVE_ORIENTATION (arrows pointing upwards)
  * - PLANE_DECORATION_NEGATIVE_ORIENTATION (arrows pointing downwards)
  *
- * See also mitk::Geometry2DDataMapper2D::DrawOrientationArrow()
+ * See also mitk::PlaneGeometryDataMapper2D::DrawOrientationArrow()
  */
 class MITK_CORE_EXPORT PlaneOrientationProperty : public EnumerationProperty
 {
 public:
 
   mitkClassMacro( PlaneOrientationProperty, EnumerationProperty );
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   mitkNewMacro1Param(PlaneOrientationProperty, const IdType&);
 
   mitkNewMacro1Param(PlaneOrientationProperty, const std::string&);
 
   enum
   {
     PLANE_DECORATION_NONE,
     PLANE_DECORATION_POSITIVE_ORIENTATION,
     PLANE_DECORATION_NEGATIVE_ORIENTATION
   };
 
   /**
    * Returns the state of plane decoration.
    */
   virtual int GetPlaneDecoration();
 
   /**
    * Sets the decoration type to no decoration.
    */
   virtual void SetPlaneDecorationToNone();
 
   /**
    * Sets the decoration type to arrows in positive plane direction.
    */
   virtual void SetPlaneDecorationToPositiveOrientation();
 
   /**
    * Sets the decoration type to arrows in negative plane direction.
    */
   virtual void SetPlaneDecorationToNegativeOrientation();
 
   using BaseProperty::operator=;
 
 protected:
 
   /**
    * Constructor. Sets the decoration type to none.
    */
   PlaneOrientationProperty( );
 
   /**
    * Constructor. Sets the decoration type to the given value. If it is not
    * valid, the interpolation is set to none
    */
   PlaneOrientationProperty( const IdType &value );
 
   /**
    * Constructor. Sets the decoration type to the given value. If it is not
    * valid, the representation is set to none
    */
   PlaneOrientationProperty( const std::string &value );
 
 
   /**
    * this function is overridden as protected, so that the user may not add
    * additional invalid types.
    */
   virtual bool AddEnum( const std::string &name, const IdType &id );
 
   /**
    * Adds the standard enumeration types with corresponding strings.
    */
   virtual void AddDecorationTypes();
 
 private:
 
   // purposely not implemented
   PlaneOrientationProperty& operator=(const PlaneOrientationProperty&);
 
   virtual itk::LightObject::Pointer InternalClone() const;
 };
 
 #ifdef _MSC_VER
 # pragma warning(pop)
 #endif
 
 } // end of namespace mitk
 
 
 #endif
diff --git a/Core/Code/DataManagement/mitkSlicedData.cpp b/Core/Code/DataManagement/mitkSlicedData.cpp
index 0de1afde52..2f9121153c 100644
--- a/Core/Code/DataManagement/mitkSlicedData.cpp
+++ b/Core/Code/DataManagement/mitkSlicedData.cpp
@@ -1,359 +1,359 @@
 /*===================================================================
 
 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 "mitkSlicedData.h"
 #include "mitkBaseProcess.h"
 #include <mitkProportionalTimeGeometry.h>
 
 
 mitk::SlicedData::SlicedData() : m_UseLargestPossibleRegion(false)
 {
   unsigned int i;
   for(i=0;i<4;++i)
   {
     m_LargestPossibleRegion.SetIndex(i, 0);
     m_LargestPossibleRegion.SetSize (i, 1);
   }
 }
 
 mitk::SlicedData::SlicedData( const SlicedData &other ): BaseData(other),
 m_LargestPossibleRegion(other.m_LargestPossibleRegion),
 m_RequestedRegion(other.m_RequestedRegion),
 m_BufferedRegion(other.m_BufferedRegion),
 m_UseLargestPossibleRegion(other.m_UseLargestPossibleRegion)
 {
 
 }
 mitk::SlicedData::~SlicedData()
 {
 }
 
 void mitk::SlicedData::UpdateOutputInformation()
 {
   Superclass::UpdateOutputInformation();
 
   if (this->GetSource().IsNull())
   // If we don't have a source, then let's make our Image
   // span our buffer
   {
     m_UseLargestPossibleRegion = true;
   }
 
   // Now we should know what our largest possible region is. If our
   // requested region was not set yet, (or has been set to something
   // invalid - with no data in it ) then set it to the largest possible
   // region.
   if ( ! m_RequestedRegionInitialized)
   {
     this->SetRequestedRegionToLargestPossibleRegion();
     m_RequestedRegionInitialized = true;
   }
 
   m_LastRequestedRegionWasOutsideOfTheBufferedRegion = 0;
 }
 
 void mitk::SlicedData::PrepareForNewData()
 {
   if ( GetUpdateMTime() < GetPipelineMTime() || GetDataReleased() )
   {
    ReleaseData();
   }
 }
 
 void mitk::SlicedData::SetRequestedRegionToLargestPossibleRegion()
 {
   m_UseLargestPossibleRegion = true;
   if(GetGeometry()==NULL)
     return;
   unsigned int i;
   const RegionType::IndexType & index = GetLargestPossibleRegion().GetIndex();
   const RegionType::SizeType & size = GetLargestPossibleRegion().GetSize();
   for(i=0;i<RegionDimension;++i)
   {
     m_RequestedRegion.SetIndex(i, index[i]);
     m_RequestedRegion.SetSize(i, size[i]);
   }
 }
 
 bool mitk::SlicedData::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   // Is the requested region within the currently buffered data?
   // SlicedData and subclasses store entire volumes or slices. The
   // methods IsVolumeSet() and IsSliceSet are provided to check,
   // a volume or slice, respectively, is available. Thus, these
   // methods used here.
   const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
 
   const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
   const SizeType& largestPossibleRegionSize
     = GetLargestPossibleRegion().GetSize();
 
   // are whole channels requested?
   int c, cEnd;
   c=requestedRegionIndex[4];
   cEnd=c+static_cast<long>(requestedRegionSize[4]);
   if(requestedRegionSize[3] == largestPossibleRegionSize[3])
   {
     for (; c< cEnd; ++c)
       if(IsChannelSet(c)==false) return true;
     return false;
   }
 
   // are whole volumes requested?
   int t, tEnd;
   t=requestedRegionIndex[3];
   tEnd=t+static_cast<long>(requestedRegionSize[3]);
   if(requestedRegionSize[2] == largestPossibleRegionSize[2])
   {
     for (; c< cEnd; ++c)
       for (; t< tEnd; ++t)
         if(IsVolumeSet(t, c)==false) return true;
     return false;
   }
 
   // ok, only slices are requested. Check if they are available.
   int s, sEnd;
   s=requestedRegionIndex[2];
   sEnd=s+static_cast<long>(requestedRegionSize[2]);
   for (; c< cEnd; ++c)
     for (; t< tEnd; ++t)
       for (; s< sEnd; ++s)
         if(IsSliceSet(s, t, c)==false) return true;
 
   return false;
 }
 
 bool mitk::SlicedData::VerifyRequestedRegion()
 {
   if(GetTimeGeometry() == NULL) return false;
 
   unsigned int i;
 
   // Is the requested region within the LargestPossibleRegion?
   // Note that the test is indeed against the largest possible region
   // rather than the buffered region; see DataObject::VerifyRequestedRegion.
   const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
   const IndexType &largestPossibleRegionIndex
     = GetLargestPossibleRegion().GetIndex();
 
   const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
   const SizeType& largestPossibleRegionSize
     = GetLargestPossibleRegion().GetSize();
 
   for (i=0; i< RegionDimension; ++i)
   {
     if ( (requestedRegionIndex[i] < largestPossibleRegionIndex[i]) ||
       ((requestedRegionIndex[i] + static_cast<long>(requestedRegionSize[i]))
     > (largestPossibleRegionIndex[i]+static_cast<long>(largestPossibleRegionSize[i]))))
     {
       return false;
     }
   }
 
   return true;
 }
 
 void mitk::SlicedData::SetRequestedRegion( const itk::DataObject *data)
 {
   m_UseLargestPossibleRegion=false;
 
   const mitk::SlicedData *slicedData = dynamic_cast<const mitk::SlicedData*>(data);
 
   if (slicedData)
   {
     m_RequestedRegion = slicedData->GetRequestedRegion();
     m_RequestedRegionInitialized = true;
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
   }
 }
 
 void mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType *region)
 {
   m_UseLargestPossibleRegion=false;
 
   if(region!=NULL)
   {
     m_RequestedRegion = *region;
     m_RequestedRegionInitialized = true;
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(SlicedData*).name() );
   }
 }
 
 void mitk::SlicedData::SetLargestPossibleRegion(SlicedData::RegionType *region)
 {
 
   if(region!=NULL)
   {
     m_LargestPossibleRegion = *region;
     m_UseLargestPossibleRegion=true;
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::SlicedData::SetLargestPossibleRegion(SlicedData::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(SlicedData*).name() );
   }
 }
 
 void mitk::SlicedData::CopyInformation(const itk::DataObject *data)
 {
   // Standard call to the superclass' method
   Superclass::CopyInformation(data);
 
   const mitk::SlicedData *slicedData;
 
   slicedData = dynamic_cast<const mitk::SlicedData*>(data);
 
   if (slicedData)
   {
     m_LargestPossibleRegion = slicedData->GetLargestPossibleRegion();
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::SlicedData::CopyInformation(const DataObject *data) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
   }
 }
 
-//const mitk::PlaneGeometry* mitk::SlicedData::GetGeometry2D(int s, int t) const
+//const mitk::PlaneGeometry* mitk::SlicedData::GetPlaneGeometry(int s, int t) const
 //{
 //  const_cast<SlicedData*>(this)->SetRequestedRegionToLargestPossibleRegion();
 //
 //  const_cast<SlicedData*>(this)->UpdateOutputInformation();
 //
-//  return GetSlicedGeometry(t)->GetGeometry2D(s);
+//  return GetSlicedGeometry(t)->GetPlaneGeometry(s);
 //}
 //
 mitk::SlicedGeometry3D* mitk::SlicedData::GetSlicedGeometry(unsigned int t) const
 {
   if (GetTimeGeometry() == NULL)
     return NULL;
   return dynamic_cast<SlicedGeometry3D*>(GetTimeGeometry()->GetGeometryForTimeStep(t).GetPointer());
 }
 
 const mitk::SlicedGeometry3D* mitk::SlicedData::GetUpdatedSlicedGeometry(unsigned int t)
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
   return GetSlicedGeometry(t);
 }
 
 void mitk::SlicedData::SetGeometry(BaseGeometry* aGeometry3D)
 {
   if(aGeometry3D!=NULL)
   {
     ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
     SlicedGeometry3D::Pointer slicedGeometry = dynamic_cast<SlicedGeometry3D*>(aGeometry3D);
     if(slicedGeometry.IsNull())
     {
       PlaneGeometry* geometry2d = dynamic_cast<PlaneGeometry*>(aGeometry3D);
       if(geometry2d!=NULL)
       {
-        if((GetSlicedGeometry()->GetGeometry2D(0)==geometry2d) && (GetSlicedGeometry()->GetSlices()==1))
+        if((GetSlicedGeometry()->GetPlaneGeometry(0)==geometry2d) && (GetSlicedGeometry()->GetSlices()==1))
           return;
         slicedGeometry = SlicedGeometry3D::New();
         slicedGeometry->InitializeEvenlySpaced(geometry2d, 1);
       }
       else
       {
         slicedGeometry = SlicedGeometry3D::New();
         PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
         planeGeometry->InitializeStandardPlane(aGeometry3D);
         slicedGeometry->InitializeEvenlySpaced(planeGeometry, (unsigned int)(aGeometry3D->GetExtent(2)));
       }
     }
     assert(slicedGeometry.IsNotNull());
 
     timeGeometry->Initialize(slicedGeometry, 1);
     Superclass::SetTimeGeometry(timeGeometry);
   }
   else
   {
     if(GetGeometry()==NULL)
       return;
     Superclass::SetGeometry(NULL);
   }
 }
 
 void mitk::SlicedData::SetSpacing(const ScalarType aSpacing[3])
 {
   this->SetSpacing((mitk::Vector3D)aSpacing);
 }
 
 void mitk::SlicedData::SetOrigin(const mitk::Point3D& origin)
 {
   TimeGeometry* timeGeometry = GetTimeGeometry();
 
   assert(timeGeometry!=NULL);
 
   mitk::SlicedGeometry3D* slicedGeometry;
 
   unsigned int steps = timeGeometry->CountTimeSteps();
 
   for(unsigned int timestep = 0; timestep < steps; ++timestep)
   {
     slicedGeometry = GetSlicedGeometry(timestep);
     if(slicedGeometry != NULL)
     {
       slicedGeometry->SetOrigin(origin);
       if(slicedGeometry->GetEvenlySpaced())
       {
-        mitk::PlaneGeometry* geometry2D = slicedGeometry->GetGeometry2D(0);
+        mitk::PlaneGeometry* geometry2D = slicedGeometry->GetPlaneGeometry(0);
         geometry2D->SetOrigin(origin);
         slicedGeometry->InitializeEvenlySpaced(geometry2D, slicedGeometry->GetSlices());
       }
     }
     //ProportionalTimeGeometry* timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(GetTimeGeometry());
     //if(timeGeometry != NULL)
     //{
     //  timeGeometry->Initialize(slicedGeometry, steps);
     //  break;
     //}
   }
 }
 
 void mitk::SlicedData::SetSpacing(mitk::Vector3D aSpacing)
 {
   TimeGeometry* timeGeometry = GetTimeGeometry();
 
   assert(timeGeometry!=NULL);
 
   mitk::SlicedGeometry3D* slicedGeometry;
 
   unsigned int steps = timeGeometry->CountTimeSteps();
 
   for(unsigned int timestep = 0; timestep < steps; ++timestep)
   {
     slicedGeometry = GetSlicedGeometry(timestep);
     if(slicedGeometry != NULL)
     {
       slicedGeometry->SetSpacing(aSpacing);
     }
   }
   timeGeometry->Update();
 }
 
 
diff --git a/Core/Code/DataManagement/mitkSlicedData.h b/Core/Code/DataManagement/mitkSlicedData.h
index 64791b7883..fa57bfd326 100644
--- a/Core/Code/DataManagement/mitkSlicedData.h
+++ b/Core/Code/DataManagement/mitkSlicedData.h
@@ -1,227 +1,227 @@
 /*===================================================================
 
 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 SLICEDDATA_H_HEADER_INCLUDED
 #define SLICEDDATA_H_HEADER_INCLUDED
 
 #include <MitkCoreExports.h>
 #include "mitkBaseData.h"
 #include "mitkSlicedGeometry3D.h"
 #include "itkIndex.h"
 #include "itkOffset.h"
 #include "itkSize.h"
 #include "itkImageRegion.h"
 
 namespace mitk {
 
 class SlicedGeometry3D;
 
 //##Documentation
 //## @brief Super class of data objects consisting of slices
 //##
 //## Super class of data objects consisting of slices, e.g., images or a stack
-//## of contours. (GetGeometry will return a Geometry3D containing PlaneGeometry
+//## of contours. (GetGeometry will return a BaseGeometry containing PlaneGeometry
 //## objects).
 //##
 //## SlicedData-objects have geometries of type SlicedGeometry3D or sub-classes.
 //## @ingroup Data
 class MITK_CORE_EXPORT SlicedData : public BaseData
 {
 public:
   mitkClassMacro(SlicedData, BaseData);
 
   itkStaticConstMacro(RegionDimension, unsigned int, 5);
 
   /** Region typedef support. A region is used to specify a subset of a @a SlicedData. */
   typedef itk::ImageRegion<RegionDimension>  RegionType;
 
   /** Index typedef support. An index is used to access pixel values. */
   typedef itk::Index<RegionDimension>  IndexType;
   typedef IndexType::IndexValueType  IndexValueType;
 
   /** Offset typedef support. An offset represent relative position
   * between indices. */
   typedef itk::Offset<RegionDimension>  OffsetType;
   typedef OffsetType::OffsetValueType OffsetValueType;
 
   /** Size typedef support. A size is used to define region bounds. */
   typedef itk::Size<RegionDimension>  SizeType;
   typedef SizeType::SizeValueType SizeValueType;
 
   //##Documentation
   //## Update the information for this DataObject so that it can be used as
   //## an output of a ProcessObject.  This method is used in the pipeline
   //## mechanism to propagate information and initialize the meta data
   //## associated with a itk::DataObject.  Any implementation of this method
   //## in a derived class of itk::DataObject is assumed to call its source's
   //## ProcessObject::UpdateOutputInformation() which determines modified
   //## times, LargestPossibleRegions, and any extra meta data like spacing,
   //## origin, etc.
   virtual void UpdateOutputInformation();
 
   virtual void PrepareForNewData();
 
   //##Documentation
   //## Set the RequestedRegion to the LargestPossibleRegion.  This forces a
   //## filter to produce all of the output in one execution (i.e. not
   //## streaming) on the next call to Update().
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   //##Documentation
   //## Determine whether the RequestedRegion is outside of the
   //## BufferedRegion. This method returns true if the RequestedRegion is
   //## outside the BufferedRegion (true if at least one pixel is outside).
   //## This is used by the pipeline mechanism to determine whether a filter
   //## needs to re-execute in order to satisfy the current request.  If the
   //## current RequestedRegion is already inside the BufferedRegion from the
   //## previous execution (and the current filter is up to date), then a
   //## given filter does not need to re-execute
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   //##Documentation
   //## @brief Verify that the RequestedRegion is within the
   //## LargestPossibleRegion.
   //##
   //## Verify that the RequestedRegion is within the LargestPossibleRegion.
   //## If the RequestedRegion is not within the LargestPossibleRegion,
   //## then the filter cannot possibly satisfy the request. This method
   //## returns true if the request can be satisfied (even if it will be
   //## necessary to process the entire LargestPossibleRegion) and
   //## returns false otherwise.  This method is used by
   //## PropagateRequestedRegion().  PropagateRequestedRegion() throws a
   //## InvalidRequestedRegionError exception if the requested region is
   //## not within the LargestPossibleRegion.
   virtual bool VerifyRequestedRegion();
 
   //##Documentation
   //## Set the requested region from this data object to match the requested
   //## region of the data object passed in as a parameter.  This method is
   //## implemented in the concrete subclasses of DataObject.
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
   //##Documentation
   //## Set the requested region from this data object to match the requested
   //## region of the data object passed in as a parameter.  This method is
   //## implemented in the concrete subclasses of DataObject.
   virtual void SetRequestedRegion(SlicedData::RegionType *region);
 
   /*! Documentation
   \brief Sets the largest possible region.
   The largest possible region is the entire region occupied by the data object.
   Note that the largest possible region should always be bigger then the requested region
   of a certain operation.*/
   void SetLargestPossibleRegion(SlicedData::RegionType *region);
 
   const RegionType& GetLargestPossibleRegion() const
   {
     return m_LargestPossibleRegion;
   }
 
   //##Documentation
   //## Get the region object that defines the size and starting index
   //## for the region of the image requested (i.e., the region of the
   //## image to be operated on by a filter).
   virtual const RegionType& GetRequestedRegion() const
   {
     return m_RequestedRegion;
   }
 
   virtual bool IsSliceSet(int s = 0, int t = 0, int n = 0) const = 0;
   virtual bool IsVolumeSet(int t = 0, int n = 0) const = 0;
   virtual bool IsChannelSet(int n = 0) const = 0;
   virtual void CopyInformation(const itk::DataObject *data);
 
   //##Documentation
   //## @brief Get the number of channels
   unsigned int GetNumberOfChannels() const
   {
     return m_LargestPossibleRegion.GetSize(4);
   }
 
   ////##Documentation
   ////## @brief Return the PlaneGeometry of the slice (@a s, @a t).
   ////##
-  ////## The method does not simply call GetGeometry()->GetGeometry2D(). Before doing this, it
+  ////## The method does not simply call GetGeometry()->GetPlaneGeometry(). Before doing this, it
   ////## makes sure that the PlaneGeometry is up-to-date before returning it (by
   ////## setting the update extent appropriately and calling
   ////## UpdateOutputInformation).
   ////##
-  ////## @warning GetGeometry2D not yet completely implemented.
+  ////## @warning GetPlaneGeometry not yet completely implemented.
   ////## @todo Appropriate setting of the update extent is missing.
-  //virtual const mitk::PlaneGeometry* GetGeometry2D(int s, int t=0) const;
+  //virtual const mitk::PlaneGeometry* GetPlaneGeometry(int s, int t=0) const;
 
   //##Documentation
   //## @brief Convenience access method for the geometry, which is of type SlicedGeometry3D (or a sub-class of it).
   //##
   //## @em No update will be called. Normally used in GenerateOutputInformation of
   //## subclasses of BaseProcess.
   SlicedGeometry3D* GetSlicedGeometry(unsigned int t=0) const;
 
   //##Documentation
   //## @brief Convenience access method for the geometry, which is of type SlicedGeometry3D (or a sub-class of it).
   //##
   //## The method does not simply return the value of the m_Geometry3D member.
-  //## Before doing this, it makes sure that the Geometry3D is up-to-date before
+  //## Before doing this, it makes sure that the BaseGeometry is up-to-date before
   //## returning it (by setting the update extent appropriately and calling
   //## UpdateOutputInformation).
   //##
   //## @warning GetGeometry not yet completely implemented.
   //## @todo Appropriate setting of the update extent is missing.
   const SlicedGeometry3D* GetUpdatedSlicedGeometry(unsigned int t=0);
 
   //##Documentation
-  //## @brief Set the Geometry3D of the data, which will be referenced (not copied!). It
+  //## @brief Set the BaseGeometry of the data, which will be referenced (not copied!). It
   //## has to be a sub-class of SlicedGeometry3D.
   //##
   //## @warning This method will normally be called internally by the sub-class of SlicedData
   //## during initialization.
   virtual void SetGeometry(BaseGeometry* aGeometry3D);
 
   //##Documentation
   //## @brief Convenience method for setting the origin of
   //## the SlicedGeometry3D instances of all time steps
   //##
   //## In case the SlicedGeometry3D is evenly spaced,
   //## the origin of the first slice is set to \a origin.
   //## \sa mitk::BaseData::SetOrigin
   virtual void SetOrigin(const Point3D& origin);
 
   //##Documentation
   //## @brief Convenience method for setting the spacing of
   //## the SlicedGeometry3D instances of all time steps
   virtual void SetSpacing(const ScalarType aSpacing[]);
 
   //##Documentation
   //## @brief Convenience method for setting the spacing of
   //## the SlicedGeometry3D instances of all time steps
   virtual void SetSpacing(mitk::Vector3D aSpacing);
 
 protected:
 
   SlicedData();
   SlicedData(const SlicedData &other);
   virtual ~SlicedData();
   RegionType m_LargestPossibleRegion;
 
   RegionType          m_RequestedRegion;
   RegionType          m_BufferedRegion;
   bool                m_UseLargestPossibleRegion;
 };
 
 } // namespace mitk
 
 #endif /* SLICEDDATA_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp b/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
index 6a244be06d..82edae4a94 100644
--- a/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
@@ -1,1031 +1,1031 @@
 /*===================================================================
 
 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 "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkRotationOperation.h"
 #include "mitkPlaneOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkApplyTransformMatrixOperation.h"
 #include "mitkInteractionConst.h"
 #include "mitkSliceNavigationController.h"
 
 const mitk::ScalarType PI = 3.14159265359;
 
 mitk::SlicedGeometry3D::SlicedGeometry3D()
   : m_EvenlySpaced( true ),
   m_Slices( 0 ),
   m_ReferenceGeometry( NULL ),
   m_SliceNavigationController( NULL )
 {
   m_DirectionVector.Fill(0);
   this->InitializeSlicedGeometry( m_Slices );
 }
 
 mitk::SlicedGeometry3D::SlicedGeometry3D(const SlicedGeometry3D& other)
   : Superclass(other),
   m_EvenlySpaced( other.m_EvenlySpaced ),
   m_Slices( other.m_Slices ),
   m_ReferenceGeometry( other.m_ReferenceGeometry ),
   m_SliceNavigationController( other.m_SliceNavigationController )
 {
   m_DirectionVector.Fill(0);
   SetSpacing( other.GetSpacing() );
   SetDirectionVector( other.GetDirectionVector() );
 
   if ( m_EvenlySpaced )
   {
-    PlaneGeometry::Pointer geometry = other.m_Geometry2Ds[0]->Clone();
+    PlaneGeometry::Pointer geometry = other.m_PlaneGeometries[0]->Clone();
     PlaneGeometry* geometry2D = dynamic_cast<PlaneGeometry*>(geometry.GetPointer());
     assert(geometry2D!=NULL);
-    SetGeometry2D(geometry2D, 0);
+    SetPlaneGeometry(geometry2D, 0);
   }
   else
   {
     unsigned int s;
     for ( s = 0; s < other.m_Slices; ++s )
     {
-      if ( other.m_Geometry2Ds[s].IsNull() )
+      if ( other.m_PlaneGeometries[s].IsNull() )
       {
         assert(other.m_EvenlySpaced);
-        m_Geometry2Ds[s] = NULL;
+        m_PlaneGeometries[s] = NULL;
       }
       else
       {
-        PlaneGeometry* geometry2D = other.m_Geometry2Ds[s]->Clone();
+        PlaneGeometry* geometry2D = other.m_PlaneGeometries[s]->Clone();
         assert(geometry2D!=NULL);
-        SetGeometry2D(geometry2D, s);
+        SetPlaneGeometry(geometry2D, s);
       }
     }
   }
 }
 
 mitk::SlicedGeometry3D::~SlicedGeometry3D()
 {
 }
 
 mitk::PlaneGeometry *
-  mitk::SlicedGeometry3D::GetGeometry2D( int s ) const
+  mitk::SlicedGeometry3D::GetPlaneGeometry( int s ) const
 {
   mitk::PlaneGeometry::Pointer geometry2D = NULL;
 
   if ( this->IsValidSlice(s) )
   {
-    geometry2D = m_Geometry2Ds[s];
+    geometry2D = m_PlaneGeometries[s];
 
     // If (a) m_EvenlySpaced==true, (b) we don't have a PlaneGeometry stored
     // for the requested slice, and (c) the first slice (s=0)
     // is a PlaneGeometry instance, then we calculate the geometry of the
     // requested as the plane of the first slice shifted by m_Spacing[2]*s
     // in the direction of m_DirectionVector.
     if ( (m_EvenlySpaced) && (geometry2D.IsNull()) )
     {
       PlaneGeometry *firstSlice = dynamic_cast< PlaneGeometry * > (
-        m_Geometry2Ds[0].GetPointer() );
+        m_PlaneGeometries[0].GetPointer() );
 
       if ( firstSlice != NULL )
       {
         if ( (m_DirectionVector[0] == 0.0)
           && (m_DirectionVector[1] == 0.0)
           && (m_DirectionVector[2] == 0.0) )
         {
           m_DirectionVector = firstSlice->GetNormal();
           m_DirectionVector.Normalize();
         }
 
         Vector3D direction;
         direction = m_DirectionVector * this->GetSpacing()[2];
 
         mitk::PlaneGeometry::Pointer requestedslice;
         requestedslice = static_cast< mitk::PlaneGeometry * >(
           firstSlice->Clone().GetPointer() );
 
         requestedslice->SetOrigin(
           requestedslice->GetOrigin() + direction * s );
 
         geometry2D = requestedslice;
-        m_Geometry2Ds[s] = geometry2D;
+        m_PlaneGeometries[s] = geometry2D;
       }
     }
     return geometry2D;
   }
   else
   {
     return NULL;
   }
 }
 
 const mitk::BoundingBox *
   mitk::SlicedGeometry3D::GetBoundingBox() const
 {
   assert(this->IsBoundingBoxNull()==false);
   return Superclass::GetBoundingBox();
 }
 
 bool
-  mitk::SlicedGeometry3D::SetGeometry2D( mitk::PlaneGeometry *geometry2D, int s )
+  mitk::SlicedGeometry3D::SetPlaneGeometry( mitk::PlaneGeometry *geometry2D, int s )
 {
   if ( this->IsValidSlice(s) )
   {
-    m_Geometry2Ds[s] = geometry2D;
-    m_Geometry2Ds[s]->SetReferenceGeometry( m_ReferenceGeometry );
+    m_PlaneGeometries[s] = geometry2D;
+    m_PlaneGeometries[s]->SetReferenceGeometry( m_ReferenceGeometry );
     return true;
   }
   return false;
 }
 
 void
   mitk::SlicedGeometry3D::InitializeSlicedGeometry( unsigned int slices )
 {
   Superclass::Initialize();
   m_Slices = slices;
 
   PlaneGeometry::Pointer gnull = NULL;
-  m_Geometry2Ds.assign( m_Slices, gnull );
+  m_PlaneGeometries.assign( m_Slices, gnull );
 
   Vector3D spacing;
   spacing.Fill( 1.0 );
   this->SetSpacing( spacing );
 
   m_DirectionVector.Fill( 0 );
 }
 
 void
   mitk::SlicedGeometry3D::InitializeEvenlySpaced(
   mitk::PlaneGeometry* geometry2D, unsigned int slices, bool flipped )
 {
   assert( geometry2D != NULL );
   this->InitializeEvenlySpaced(
     geometry2D, geometry2D->GetExtentInMM(2)/geometry2D->GetExtent(2),
     slices, flipped );
 }
 
 void
   mitk::SlicedGeometry3D::InitializeEvenlySpaced(
   mitk::PlaneGeometry* geometry2D, mitk::ScalarType zSpacing,
   unsigned int slices, bool flipped )
 {
   assert( geometry2D != NULL );
   assert( geometry2D->GetExtent(0) > 0 );
   assert( geometry2D->GetExtent(1) > 0 );
 
   geometry2D->Register();
 
   Superclass::Initialize();
   m_Slices = slices;
 
   BoundingBox::BoundsArrayType bounds = geometry2D->GetBounds();
   bounds[4] = 0;
   bounds[5] = slices;
 
   // clear and reserve
   PlaneGeometry::Pointer gnull = NULL;
-  m_Geometry2Ds.assign( m_Slices, gnull );
+  m_PlaneGeometries.assign( m_Slices, gnull );
 
   Vector3D directionVector = geometry2D->GetAxisVector(2);
   directionVector.Normalize();
   directionVector *= zSpacing;
 
   if ( flipped == false )
   {
     // Normally we should use the following four lines to create a copy of
     // the transform contrained in geometry2D, because it may not be changed
     // by us. But we know that SetSpacing creates a new transform without
     // changing the old (coming from geometry2D), so we can use the fifth
     // line instead. We check this at (**).
     //
     // AffineTransform3D::Pointer transform = AffineTransform3D::New();
     // transform->SetMatrix(geometry2D->GetIndexToWorldTransform()->GetMatrix());
     // transform->SetOffset(geometry2D->GetIndexToWorldTransform()->GetOffset());
     // SetIndexToWorldTransform(transform);
 
     this->SetIndexToWorldTransform( const_cast< AffineTransform3D * >(
       geometry2D->GetIndexToWorldTransform() ));
   }
   else
   {
     directionVector *= -1.0;
     this->SetIndexToWorldTransform( AffineTransform3D::New());
     this->GetIndexToWorldTransform()->SetMatrix(
       geometry2D->GetIndexToWorldTransform()->GetMatrix() );
 
     AffineTransform3D::OutputVectorType scaleVector;
     FillVector3D(scaleVector, 1.0, 1.0, -1.0);
     this->GetIndexToWorldTransform()->Scale(scaleVector, true);
     this->GetIndexToWorldTransform()->SetOffset(
       geometry2D->GetIndexToWorldTransform()->GetOffset() );
   }
 
   mitk::Vector3D spacing;
   FillVector3D( spacing,
     geometry2D->GetExtentInMM(0) / bounds[1],
     geometry2D->GetExtentInMM(1) / bounds[3],
     zSpacing );
 
   this->SetDirectionVector( directionVector );
   this->SetBounds( bounds );
-  this->SetGeometry2D( geometry2D, 0 );
+  this->SetPlaneGeometry( geometry2D, 0 );
   this->SetSpacing( spacing ,true);
   this->SetEvenlySpaced();
   this->SetTimeBounds( geometry2D->GetTimeBounds() );
 
   assert(this->GetIndexToWorldTransform()
     != geometry2D->GetIndexToWorldTransform()); // (**) see above.
 
   this->SetFrameOfReferenceID( geometry2D->GetFrameOfReferenceID() );
   this->SetImageGeometry( geometry2D->GetImageGeometry() );
 
   geometry2D->UnRegister();
 }
 
 void
   mitk::SlicedGeometry3D::InitializePlanes(
   const mitk::BaseGeometry *geometry3D,
   mitk::PlaneGeometry::PlaneOrientation planeorientation,
   bool top, bool frontside, bool rotated )
 {
   m_ReferenceGeometry = const_cast< BaseGeometry * >( geometry3D );
 
   PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane(
     geometry3D, top, planeorientation, frontside, rotated );
 
   ScalarType viewSpacing = 1;
   unsigned int slices = 1;
 
   switch ( planeorientation )
   {
   case PlaneGeometry::Axial:
     viewSpacing = geometry3D->GetSpacing()[2];
     slices = (unsigned int) geometry3D->GetExtent( 2 );
     break;
 
   case PlaneGeometry::Frontal:
     viewSpacing = geometry3D->GetSpacing()[1];
     slices = (unsigned int) geometry3D->GetExtent( 1 );
     break;
 
   case PlaneGeometry::Sagittal:
     viewSpacing = geometry3D->GetSpacing()[0];
     slices = (unsigned int) geometry3D->GetExtent( 0 );
     break;
 
   default:
     itkExceptionMacro("unknown PlaneOrientation");
   }
 
   mitk::Vector3D normal = this->AdjustNormal( planeGeometry->GetNormal() );
 
   ScalarType directedExtent =
     std::abs( m_ReferenceGeometry->GetExtentInMM( 0 ) * normal[0] )
     + std::abs( m_ReferenceGeometry->GetExtentInMM( 1 ) * normal[1] )
     + std::abs( m_ReferenceGeometry->GetExtentInMM( 2 ) * normal[2] );
 
   if ( directedExtent >= viewSpacing )
   {
     slices = static_cast< int >(directedExtent / viewSpacing + 0.5);
   }
   else
   {
     slices = 1;
   }
 
   bool flipped = (top == false);
 
   if ( frontside == false )
   {
     flipped = !flipped;
   }
   if ( planeorientation == PlaneGeometry::Frontal )
   {
     flipped = !flipped;
   }
 
   this->InitializeEvenlySpaced( planeGeometry, viewSpacing, slices, flipped );
 }
 
 void
   mitk::SlicedGeometry3D
   ::ReinitializePlanes( const Point3D &center, const Point3D &referencePoint )
 {
   // Need a reference frame to align the rotated planes
   if ( !m_ReferenceGeometry )
   {
     return;
   }
 
   // Get first plane of plane stack
   PlaneGeometry *firstPlane =
-    dynamic_cast< PlaneGeometry * >( m_Geometry2Ds[0].GetPointer() );
+    dynamic_cast< PlaneGeometry * >( m_PlaneGeometries[0].GetPointer() );
 
   // If plane stack is empty, exit
   if ( firstPlane == NULL )
   {
     return;
   }
 
   // Calculate the "directed" spacing when taking the plane (defined by its axes
   // vectors and normal) as the reference coordinate frame.
   //
   // This is done by calculating the radius of the ellipsoid defined by the
   // original volume spacing axes, in the direction of the respective axis of the
   // reference frame.
   mitk::Vector3D axis0 = firstPlane->GetAxisVector(0);
   mitk::Vector3D axis1 = firstPlane->GetAxisVector(1);
   mitk::Vector3D normal = firstPlane->GetNormal();
   normal.Normalize();
 
   Vector3D spacing;
   spacing[0] = this->CalculateSpacing( axis0 );
   spacing[1] = this->CalculateSpacing( axis1 );
   spacing[2] = this->CalculateSpacing( normal );
 
   Superclass::SetSpacing( spacing );
 
   // Now we need to calculate the number of slices in the plane's normal
   // direction, so that the entire volume is covered. This is done by first
   // calculating the dot product between the volume diagonal (the maximum
   // distance inside the volume) and the normal, and dividing this value by
   // the directed spacing calculated above.
   ScalarType directedExtent =
     std::abs( m_ReferenceGeometry->GetExtentInMM( 0 ) * normal[0] )
     + std::abs( m_ReferenceGeometry->GetExtentInMM( 1 ) * normal[1] )
     + std::abs( m_ReferenceGeometry->GetExtentInMM( 2 ) * normal[2] );
 
   if ( directedExtent >= spacing[2] )
   {
     m_Slices = static_cast< unsigned int >(directedExtent / spacing[2] + 0.5);
   }
   else
   {
     m_Slices = 1;
   }
 
   // The origin of our "first plane" needs to be adapted to this new extent.
   // To achieve this, we first calculate the current distance to the volume's
   // center, and then shift the origin in the direction of the normal by the
   // difference between this distance and half of the new extent.
   double centerOfRotationDistance =
     firstPlane->SignedDistanceFromPlane( center );
 
   if ( centerOfRotationDistance > 0 )
   {
     firstPlane->SetOrigin( firstPlane->GetOrigin()
       + normal * (centerOfRotationDistance - directedExtent / 2.0)
       );
     m_DirectionVector = normal;
   }
   else
   {
     firstPlane->SetOrigin( firstPlane->GetOrigin()
       + normal * (directedExtent / 2.0 + centerOfRotationDistance)
       );
     m_DirectionVector = -normal;
   }
 
   // Now we adjust this distance according with respect to the given reference
   // point: we need to make sure that the point is touched by one slice of the
   // new slice stack.
   double referencePointDistance =
     firstPlane->SignedDistanceFromPlane( referencePoint );
 
   int referencePointSlice = static_cast< int >(
     referencePointDistance / spacing[2]);
 
   double alignmentValue =
     referencePointDistance / spacing[2] - referencePointSlice;
 
   firstPlane->SetOrigin(
     firstPlane->GetOrigin() + normal * alignmentValue * spacing[2] );
 
   // Finally, we can clear the previous geometry stack and initialize it with
   // our re-initialized "first plane".
-  m_Geometry2Ds.assign( m_Slices, PlaneGeometry::Pointer( NULL ) );
+  m_PlaneGeometries.assign( m_Slices, PlaneGeometry::Pointer( NULL ) );
 
   if ( m_Slices > 0 )
   {
-    m_Geometry2Ds[0] = firstPlane;
+    m_PlaneGeometries[0] = firstPlane;
   }
 
   // Reinitialize SNC with new number of slices
   m_SliceNavigationController->GetSlice()->SetSteps( m_Slices );
 
   this->Modified();
 }
 
 double
   mitk::SlicedGeometry3D::CalculateSpacing( const mitk::Vector3D &d ) const
 {
   // Need the spacing of the underlying dataset / geometry
   if ( !m_ReferenceGeometry )
   {
     return 1.0;
   }
 
   const mitk::Vector3D &spacing = m_ReferenceGeometry->GetSpacing();
   return SlicedGeometry3D::CalculateSpacing( spacing, d );
 }
 
 double mitk::SlicedGeometry3D::CalculateSpacing( const mitk::Vector3D spacing, const mitk::Vector3D &d )
 {
   // The following can be derived from the ellipsoid equation
   //
   //   1 = x^2/a^2 + y^2/b^2 + z^2/c^2
   //
   // where (a,b,c) = spacing of original volume (ellipsoid radii)
   // and   (x,y,z) = scaled coordinates of vector d (according to ellipsoid)
   //
   double scaling = d[0]*d[0] / (spacing[0] * spacing[0])
     + d[1]*d[1] / (spacing[1] * spacing[1])
     + d[2]*d[2] / (spacing[2] * spacing[2]);
 
   scaling = sqrt( scaling );
 
   return ( sqrt( d[0]*d[0] + d[1]*d[1] + d[2]*d[2] ) / scaling );
 }
 
 mitk::Vector3D
   mitk::SlicedGeometry3D::AdjustNormal( const mitk::Vector3D &normal ) const
 {
   TransformType::Pointer inverse = TransformType::New();
   m_ReferenceGeometry->GetIndexToWorldTransform()->GetInverse( inverse );
 
   Vector3D transformedNormal = inverse->TransformVector( normal );
 
   transformedNormal.Normalize();
   return transformedNormal;
 }
 
 void
   mitk::SlicedGeometry3D::SetImageGeometry( const bool isAnImageGeometry )
 {
   Superclass::SetImageGeometry( isAnImageGeometry );
 
   mitk::BaseGeometry* geometry;
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
-    geometry = m_Geometry2Ds[s];
+    geometry = m_PlaneGeometries[s];
     if ( geometry!=NULL )
     {
       geometry->SetImageGeometry( isAnImageGeometry );
     }
   }
 }
 
 void
   mitk::SlicedGeometry3D::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
 {
   mitk::BaseGeometry* geometry;
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
-    geometry = m_Geometry2Ds[s];
+    geometry = m_PlaneGeometries[s];
     if ( geometry!=NULL )
     {
       geometry->ChangeImageGeometryConsideringOriginOffset( isAnImageGeometry );
     }
   }
 
   Superclass::ChangeImageGeometryConsideringOriginOffset( isAnImageGeometry );
 }
 
 bool
   mitk::SlicedGeometry3D::IsValidSlice( int s ) const
 {
   return ((s >= 0) && (s < (int)m_Slices));
 }
 
 void
   mitk::SlicedGeometry3D::SetReferenceGeometry( BaseGeometry *referenceGeometry )
 {
   m_ReferenceGeometry = referenceGeometry;
 
   std::vector<PlaneGeometry::Pointer>::iterator it;
 
-  for ( it = m_Geometry2Ds.begin(); it != m_Geometry2Ds.end(); ++it )
+  for ( it = m_PlaneGeometries.begin(); it != m_PlaneGeometries.end(); ++it )
   {
     (*it)->SetReferenceGeometry( referenceGeometry );
   }
 }
 
 void
   mitk::SlicedGeometry3D::PreSetSpacing( const mitk::Vector3D &aSpacing )
 {
   bool hasEvenlySpacedPlaneGeometry = false;
   mitk::Point3D origin;
   mitk::Vector3D rightDV, bottomDV;
   BoundingBox::BoundsArrayType bounds;
 
   assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
 
   // In case of evenly-spaced data: re-initialize instances of PlaneGeometry,
   // since the spacing influences them
-  if ((m_EvenlySpaced) && (m_Geometry2Ds.size() > 0))
+  if ((m_EvenlySpaced) && (m_PlaneGeometries.size() > 0))
   {
     mitk::PlaneGeometry::ConstPointer firstGeometry =
-      m_Geometry2Ds[0].GetPointer();
+      m_PlaneGeometries[0].GetPointer();
 
     const PlaneGeometry *planeGeometry =
       dynamic_cast< const PlaneGeometry * >( firstGeometry.GetPointer() );
 
     if (planeGeometry != NULL )
     {
       this->WorldToIndex( planeGeometry->GetOrigin(), origin );
       this->WorldToIndex( planeGeometry->GetAxisVector(0), rightDV );
       this->WorldToIndex( planeGeometry->GetAxisVector(1), bottomDV );
 
       bounds = planeGeometry->GetBounds();
       hasEvenlySpacedPlaneGeometry = true;
     }
   }
 
   _SetSpacing(aSpacing);
 
   mitk::PlaneGeometry::Pointer firstGeometry;
 
   // In case of evenly-spaced data: re-initialize instances of PlaneGeometry,
   // since the spacing influences them
   if ( hasEvenlySpacedPlaneGeometry )
   {
     //create planeGeometry according to new spacing
     this->IndexToWorld( origin, origin );
     this->IndexToWorld( rightDV, rightDV );
     this->IndexToWorld( bottomDV, bottomDV );
 
     mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
     planeGeometry->SetImageGeometry( this->GetImageGeometry() );
 
     planeGeometry->SetReferenceGeometry( m_ReferenceGeometry );
 
     //Store spacing, as Initialize... needs a pointer
     mitk::Vector3D lokalSpacing = this->GetSpacing();
     planeGeometry->InitializeStandardPlane(
       rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &lokalSpacing );
     planeGeometry->SetOrigin(origin);
     planeGeometry->SetBounds(bounds);
 
     firstGeometry = planeGeometry;
   }
-  else if ( (m_EvenlySpaced) && (m_Geometry2Ds.size() > 0) )
+  else if ( (m_EvenlySpaced) && (m_PlaneGeometries.size() > 0) )
   {
-    firstGeometry = m_Geometry2Ds[0].GetPointer();
+    firstGeometry = m_PlaneGeometries[0].GetPointer();
   }
 
   //clear and reserve
   PlaneGeometry::Pointer gnull=NULL;
-  m_Geometry2Ds.assign(m_Slices, gnull);
+  m_PlaneGeometries.assign(m_Slices, gnull);
 
   if ( m_Slices > 0 )
   {
-    m_Geometry2Ds[0] = firstGeometry;
+    m_PlaneGeometries[0] = firstGeometry;
   }
 
   this->Modified();
 }
 
 void
   mitk::SlicedGeometry3D
   ::SetSliceNavigationController( SliceNavigationController *snc )
 {
   m_SliceNavigationController = snc;
 }
 
 mitk::SliceNavigationController *
   mitk::SlicedGeometry3D::GetSliceNavigationController()
 {
   return m_SliceNavigationController;
 }
 
 void
   mitk::SlicedGeometry3D::SetEvenlySpaced(bool on)
 {
   if(m_EvenlySpaced!=on)
   {
     m_EvenlySpaced=on;
     this->Modified();
   }
 }
 
 void
   mitk::SlicedGeometry3D
   ::SetDirectionVector( const mitk::Vector3D& directionVector )
 {
   Vector3D newDir = directionVector;
   newDir.Normalize();
   if ( newDir != m_DirectionVector )
   {
     m_DirectionVector = newDir;
     this->Modified();
   }
 }
 
 void
   mitk::SlicedGeometry3D::PostSetTimeBounds( const mitk::TimeBounds& timebounds )
 {
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
-    if(m_Geometry2Ds[s].IsNotNull())
+    if(m_PlaneGeometries[s].IsNotNull())
     {
-      m_Geometry2Ds[s]->SetTimeBounds( timebounds );
+      m_PlaneGeometries[s]->SetTimeBounds( timebounds );
     }
   }
 }
 
 itk::LightObject::Pointer
   mitk::SlicedGeometry3D::InternalClone() const
 {
   Self::Pointer newGeometry = new SlicedGeometry3D(*this);
   newGeometry->UnRegister();
   return newGeometry.GetPointer();
 }
 
 void
   mitk::SlicedGeometry3D::PrintSelf( std::ostream& os, itk::Indent indent ) const
 {
   Superclass::PrintSelf(os,indent);
   os << indent << " EvenlySpaced: " << m_EvenlySpaced << std::endl;
   if ( m_EvenlySpaced )
   {
     os << indent << " DirectionVector: " << m_DirectionVector << std::endl;
   }
   os << indent << " Slices: " << m_Slices << std::endl;
 
   os << std::endl;
-  os << indent << " GetGeometry2D(0): ";
-  if ( this->GetGeometry2D(0) == NULL )
+  os << indent << " GetPlaneGeometry(0): ";
+  if ( this->GetPlaneGeometry(0) == NULL )
   {
     os << "NULL" << std::endl;
   }
   else
   {
-    this->GetGeometry2D(0)->Print(os, indent);
+    this->GetPlaneGeometry(0)->Print(os, indent);
   }
 }
 
 void
   mitk::SlicedGeometry3D::ExecuteOperation(Operation* operation)
 {
   switch ( operation->GetOperationType() )
   {
   case OpNOTHING:
     break;
 
   case OpROTATE:
     if ( m_EvenlySpaced )
     {
       // Need a reference frame to align the rotation
       if ( m_ReferenceGeometry )
       {
         // Clear all generated geometries and then rotate only the first slice.
         // The other slices will be re-generated on demand
 
         // Save first slice
-        PlaneGeometry::Pointer geometry2D = m_Geometry2Ds[0];
+        PlaneGeometry::Pointer geometry2D = m_PlaneGeometries[0];
 
         RotationOperation *rotOp = dynamic_cast< RotationOperation * >( operation );
 
         // Generate a RotationOperation using the dataset center instead of
         // the supplied rotation center. This is necessary so that the rotated
         // zero-plane does not shift away. The supplied center is instead used
         // to adjust the slice stack afterwards.
         Point3D center = m_ReferenceGeometry->GetCenter();
 
         RotationOperation centeredRotation(
           rotOp->GetOperationType(),
           center,
           rotOp->GetVectorOfRotation(),
           rotOp->GetAngleOfRotation()
           );
 
         // Rotate first slice
         geometry2D->ExecuteOperation( &centeredRotation );
 
         // Clear the slice stack and adjust it according to the center of
         // the dataset and the supplied rotation center (see documentation of
         // ReinitializePlanes)
         this->ReinitializePlanes( center, rotOp->GetCenterOfRotation() );
 
         geometry2D->SetSpacing(this->GetSpacing());
 
         if ( m_SliceNavigationController )
         {
           m_SliceNavigationController->SelectSliceByPoint(
             rotOp->GetCenterOfRotation() );
           m_SliceNavigationController->AdjustSliceStepperRange();
         }
 
         BaseGeometry::ExecuteOperation( &centeredRotation );
       }
       else
       {
         // we also have to consider the case, that there is no reference geometry available.
-        if ( m_Geometry2Ds.size() > 0 )
+        if ( m_PlaneGeometries.size() > 0 )
         {
           // Reach through to all slices in my container
-          for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_Geometry2Ds.begin();
-            iter != m_Geometry2Ds.end();
+          for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_PlaneGeometries.begin();
+            iter != m_PlaneGeometries.end();
             ++iter)
           {
             // Test for empty slices, which can happen if evenly spaced geometry
             if ((*iter).IsNotNull())
             {
               (*iter)->ExecuteOperation(operation);
             }
           }
 
           // rotate overall geometry
           RotationOperation *rotOp = dynamic_cast< RotationOperation * >( operation );
           BaseGeometry::ExecuteOperation( rotOp);
         }
       }
     }
     else
     {
       // Reach through to all slices
-      for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_Geometry2Ds.begin();
-        iter != m_Geometry2Ds.end();
+      for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_PlaneGeometries.begin();
+        iter != m_PlaneGeometries.end();
         ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   case OpORIENT:
     if ( m_EvenlySpaced )
     {
       // get operation data
       PlaneOperation *planeOp = dynamic_cast< PlaneOperation * >( operation );
 
       // Get first slice
-      PlaneGeometry::Pointer geometry2D = m_Geometry2Ds[0];
+      PlaneGeometry::Pointer geometry2D = m_PlaneGeometries[0];
       PlaneGeometry *planeGeometry = dynamic_cast< PlaneGeometry * >(
         geometry2D.GetPointer() );
 
       // Need a PlaneGeometry, a PlaneOperation and a reference frame to
       // carry out the re-orientation. If not all avaialble, stop here
       if ( !m_ReferenceGeometry || !planeGeometry || !planeOp )
       {
         break;
       }
 
       // General Behavior:
       // Clear all generated geometries and then rotate only the first slice.
       // The other slices will be re-generated on demand
 
       //
       // 1st Step: Reorient Normal Vector of first plane
       //
       Point3D center = planeOp->GetPoint(); //m_ReferenceGeometry->GetCenter();
       mitk::Vector3D currentNormal = planeGeometry->GetNormal();
       mitk::Vector3D newNormal;
       if (planeOp->AreAxisDefined())
       {
         // If planeOp was defined by one centerpoint and two axis vectors
         newNormal = CrossProduct(planeOp->GetAxisVec0(), planeOp->GetAxisVec1());
       }
       else
       {
         // If planeOp was defined by one centerpoint and one normal vector
         newNormal = planeOp->GetNormal();
       }
 
       // Get Rotation axis und angle
       currentNormal.Normalize();
       newNormal.Normalize();
       ScalarType rotationAngle = angle(currentNormal.GetVnlVector(),newNormal.GetVnlVector());
 
       rotationAngle *= 180.0 / vnl_math::pi; // from rad to deg
       Vector3D rotationAxis = itk::CrossProduct( currentNormal, newNormal );
       if (std::abs(rotationAngle-180) < mitk::eps )
       {
         // current Normal and desired normal are not linear independent!!(e.g 1,0,0 and -1,0,0).
         // Rotation Axis should be ANY vector that is 90� to current Normal
         mitk::Vector3D helpNormal;
         helpNormal = currentNormal;
         helpNormal[0] += 1;
         helpNormal[1] -= 1;
         helpNormal[2] += 1;
         helpNormal.Normalize();
         rotationAxis = itk::CrossProduct( helpNormal, currentNormal );
       }
 
       RotationOperation centeredRotation(
         mitk::OpROTATE,
         center,
         rotationAxis,
         rotationAngle
         );
 
       // Rotate first slice
       geometry2D->ExecuteOperation( &centeredRotation );
 
       // Reinitialize planes and select slice, if my rotations are all done.
       if (!planeOp->AreAxisDefined())
       {
         // Clear the slice stack and adjust it according to the center of
         // rotation and plane position (see documentation of ReinitializePlanes)
         this->ReinitializePlanes( center, planeOp->GetPoint() );
 
         if ( m_SliceNavigationController )
         {
           m_SliceNavigationController->SelectSliceByPoint( planeOp->GetPoint() );
           m_SliceNavigationController->AdjustSliceStepperRange();
         }
       }
 
       // Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
       BaseGeometry::ExecuteOperation( &centeredRotation );
 
       //
       // 2nd step. If axis vectors were defined, rotate the plane around its normal to fit these
       //
 
       if (planeOp->AreAxisDefined())
       {
         mitk::Vector3D vecAxixNew = planeOp->GetAxisVec0();
         vecAxixNew.Normalize();
         mitk::Vector3D VecAxisCurr = geometry2D->GetAxisVector(0);
         VecAxisCurr.Normalize();
 
         ScalarType rotationAngle = angle(VecAxisCurr.GetVnlVector(),vecAxixNew.GetVnlVector());
         rotationAngle = rotationAngle * 180 / PI; // Rad to Deg
 
         // we rotate around the normal of the plane, but we do not know, if we need to rotate clockwise
         // or anti-clockwise. So we rotate around the crossproduct of old and new Axisvector.
         // Since both axis vectors lie in the plane, the crossproduct is the planes normal or the negative planes normal
 
         rotationAxis = itk::CrossProduct( VecAxisCurr, vecAxixNew  );
         if (std::abs(rotationAngle-180) < mitk::eps )
         {
           // current axisVec and desired axisVec are not linear independent!!(e.g 1,0,0 and -1,0,0).
           // Rotation Axis can be just plane Normal. (have to rotate by 180�)
           rotationAxis = newNormal;
         }
 
         // Perfom Rotation
         mitk::RotationOperation op(mitk::OpROTATE, center, rotationAxis, rotationAngle);
         geometry2D->ExecuteOperation( &op );
 
         // Apply changes on first slice to whole slice stack
         this->ReinitializePlanes( center, planeOp->GetPoint() );
 
         if ( m_SliceNavigationController )
         {
           m_SliceNavigationController->SelectSliceByPoint( planeOp->GetPoint() );
           m_SliceNavigationController->AdjustSliceStepperRange();
         }
 
         // Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
         BaseGeometry::ExecuteOperation( &op );
       }
     }
     else
     {
       // Reach through to all slices
-      for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_Geometry2Ds.begin();
-        iter != m_Geometry2Ds.end();
+      for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_PlaneGeometries.begin();
+        iter != m_PlaneGeometries.end();
         ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   case OpRESTOREPLANEPOSITION:
     if ( m_EvenlySpaced )
     {
       // Save first slice
-      PlaneGeometry::Pointer geometry2D = m_Geometry2Ds[0];
+      PlaneGeometry::Pointer geometry2D = m_PlaneGeometries[0];
 
       PlaneGeometry* planeGeometry = dynamic_cast< PlaneGeometry * >(
         geometry2D.GetPointer() );
 
       RestorePlanePositionOperation *restorePlaneOp = dynamic_cast< RestorePlanePositionOperation* >( operation );
 
       // Need a PlaneGeometry, a PlaneOperation and a reference frame to
       // carry out the re-orientation
       if ( m_ReferenceGeometry && planeGeometry && restorePlaneOp )
       {
         // Clear all generated geometries and then rotate only the first slice.
         // The other slices will be re-generated on demand
 
         // Rotate first slice
         geometry2D->ExecuteOperation( restorePlaneOp );
 
         m_DirectionVector = restorePlaneOp->GetDirectionVector();
 
         double centerOfRotationDistance =
           planeGeometry->SignedDistanceFromPlane( m_ReferenceGeometry->GetCenter() );
 
         if ( centerOfRotationDistance > 0 )
         {
           m_DirectionVector = m_DirectionVector;
         }
         else
         {
           m_DirectionVector = -m_DirectionVector;
         }
 
         Vector3D spacing = restorePlaneOp->GetSpacing();
 
         Superclass::SetSpacing( spacing );
 
         // /*Now we need to calculate the number of slices in the plane's normal
         // direction, so that the entire volume is covered. This is done by first
         // calculating the dot product between the volume diagonal (the maximum
         // distance inside the volume) and the normal, and dividing this value by
         // the directed spacing calculated above.*/
         ScalarType directedExtent =
           std::abs( m_ReferenceGeometry->GetExtentInMM( 0 ) * m_DirectionVector[0] )
           + std::abs( m_ReferenceGeometry->GetExtentInMM( 1 ) * m_DirectionVector[1] )
           + std::abs( m_ReferenceGeometry->GetExtentInMM( 2 ) * m_DirectionVector[2] );
 
         if ( directedExtent >= spacing[2] )
         {
           m_Slices = static_cast< unsigned int >(directedExtent / spacing[2] + 0.5);
         }
         else
         {
           m_Slices = 1;
         }
 
-        m_Geometry2Ds.assign( m_Slices, PlaneGeometry::Pointer( NULL ) );
+        m_PlaneGeometries.assign( m_Slices, PlaneGeometry::Pointer( NULL ) );
 
         if ( m_Slices > 0 )
         {
-          m_Geometry2Ds[0] = geometry2D;
+          m_PlaneGeometries[0] = geometry2D;
         }
 
         m_SliceNavigationController->GetSlice()->SetSteps( m_Slices );
 
         this->Modified();
 
         //End Reinitialization
 
         if ( m_SliceNavigationController )
         {
           m_SliceNavigationController->GetSlice()->SetPos( restorePlaneOp->GetPos() );
           m_SliceNavigationController->AdjustSliceStepperRange();
         }
         BaseGeometry::ExecuteOperation(restorePlaneOp);
       }
     }
     else
     {
       // Reach through to all slices
-      for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_Geometry2Ds.begin();
-        iter != m_Geometry2Ds.end();
+      for (std::vector<PlaneGeometry::Pointer>::iterator iter = m_PlaneGeometries.begin();
+        iter != m_PlaneGeometries.end();
         ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   case OpAPPLYTRANSFORMMATRIX:
 
     // Clear all generated geometries and then transform only the first slice.
     // The other slices will be re-generated on demand
 
     // Save first slice
-    PlaneGeometry::Pointer geometry2D = m_Geometry2Ds[0];
+    PlaneGeometry::Pointer geometry2D = m_PlaneGeometries[0];
 
     ApplyTransformMatrixOperation *applyMatrixOp = dynamic_cast< ApplyTransformMatrixOperation* >( operation );
 
     // Apply transformation to first plane
     geometry2D->ExecuteOperation( applyMatrixOp );
 
     // Generate a ApplyTransformMatrixOperation using the dataset center instead of
     // the supplied rotation center. The supplied center is instead used to adjust the
     // slice stack afterwards (see OpROTATE).
     Point3D center = m_ReferenceGeometry->GetCenter();
 
     // Clear the slice stack and adjust it according to the center of
     // the dataset and the supplied rotation center (see documentation of
     // ReinitializePlanes)
     this->ReinitializePlanes( center, applyMatrixOp->GetReferencePoint() );
 
     BaseGeometry::ExecuteOperation( applyMatrixOp );
     break;
   }
 
   this->Modified();
 }
diff --git a/Core/Code/DataManagement/mitkSlicedGeometry3D.h b/Core/Code/DataManagement/mitkSlicedGeometry3D.h
index 584c36d641..ede4f7debb 100644
--- a/Core/Code/DataManagement/mitkSlicedGeometry3D.h
+++ b/Core/Code/DataManagement/mitkSlicedGeometry3D.h
@@ -1,314 +1,314 @@
 /*===================================================================
 
 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 MITKSLICEDGEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 #define MITKSLICEDGEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 
 #include "mitkBaseGeometry.h"
 #include "mitkPlaneGeometry.h"
 
 namespace mitk {
   class SliceNavigationController;
   class NavigationController;
 
   /** \brief Describes the geometry of a data object consisting of slices.
- *
+  *
   * A PlaneGeometry can be requested for each slice. In the case of
- * \em evenly-spaced, \em plane geometries (m_EvenlySpaced==true),
- * only the 2D-geometry of the first slice has to be set (to an instance of
- * PlaneGeometry). The 2D geometries of the other slices are calculated
- * by shifting the first slice in the direction m_DirectionVector by
- * m_Spacing.z * sliceNumber. The m_Spacing member (which is only
- * relevant in the case m_EvenlySpaced==true) descibes the size of a voxel
- * (in mm), i.e., m_Spacing.x is the voxel width in the x-direction of the
- * plane. It is derived from the reference geometry of this SlicedGeometry3D,
- * which usually would be the global geometry describing how datasets are to
- * be resliced.
- *
- * By default, slices are oriented in the direction of one of the main axes
- * (x, y, z). However, by means of rotation, it is possible to realign the
- * slices in any possible direction. In case of an inclined plane, the spacing
- * is derived as a product of the (regular) geometry spacing and the direction
- * vector of the plane.
- *
- * SlicedGeometry3D and the associated Geometry2Ds have to be initialized in
- * the method GenerateOutputInformation() of BaseProcess (or CopyInformation /
- * UpdateOutputInformation of BaseData, if possible, e.g., by analyzing pic
- * tags in Image) subclasses. See also
- *
- * \sa itk::ProcessObject::GenerateOutputInformation(),
- * \sa itk::DataObject::CopyInformation() and
- * \a itk::DataObject::UpdateOutputInformation().
- *
- * Rule: everything is in mm (or ms for temporal information) if not
- * stated otherwise.
- *
- * \warning The hull (i.e., transform, bounding-box and
- * time-bounds) is only guaranteed to be up-to-date after calling
- * UpdateInformation().
- *
- * \ingroup Geometry
- */
+  * \em evenly-spaced, \em plane geometries (m_EvenlySpaced==true),
+  * only the 2D-geometry of the first slice has to be set (to an instance of
+  * PlaneGeometry). The 2D geometries of the other slices are calculated
+  * by shifting the first slice in the direction m_DirectionVector by
+  * m_Spacing.z * sliceNumber. The m_Spacing member (which is only
+  * relevant in the case m_EvenlySpaced==true) descibes the size of a voxel
+  * (in mm), i.e., m_Spacing.x is the voxel width in the x-direction of the
+  * plane. It is derived from the reference geometry of this SlicedGeometry3D,
+  * which usually would be the global geometry describing how datasets are to
+  * be resliced.
+  *
+  * By default, slices are oriented in the direction of one of the main axes
+  * (x, y, z). However, by means of rotation, it is possible to realign the
+  * slices in any possible direction. In case of an inclined plane, the spacing
+  * is derived as a product of the (regular) geometry spacing and the direction
+  * vector of the plane.
+  *
+  * SlicedGeometry3D and the associated PlaneGeometries have to be initialized in
+  * the method GenerateOutputInformation() of BaseProcess (or CopyInformation /
+  * UpdateOutputInformation of BaseData, if possible, e.g., by analyzing pic
+  * tags in Image) subclasses. See also
+  *
+  * \sa itk::ProcessObject::GenerateOutputInformation(),
+  * \sa itk::DataObject::CopyInformation() and
+  * \a itk::DataObject::UpdateOutputInformation().
+  *
+  * Rule: everything is in mm (or ms for temporal information) if not
+  * stated otherwise.
+  *
+  * \warning The hull (i.e., transform, bounding-box and
+  * time-bounds) is only guaranteed to be up-to-date after calling
+  * UpdateInformation().
+  *
+  * \ingroup Geometry
+  */
   class MITK_CORE_EXPORT SlicedGeometry3D : public mitk::BaseGeometry
   {
   public:
     mitkClassMacro(SlicedGeometry3D, BaseGeometry);
 
-  /** Method for creation through the object factory. */
-  itkFactorylessNewMacro(Self)
-  itkCloneMacro(Self)
+    /** Method for creation through the object factory. */
+    itkFactorylessNewMacro(Self)
+      itkCloneMacro(Self)
+
+      /**
+      * \brief Returns the PlaneGeometry of the slice (\a s).
+      *
+      * If (a) m_EvenlySpaced==true, (b) we don't have a PlaneGeometry stored
+      * for the requested slice, and (c) the first slice (s=0)
+      * is a PlaneGeometry instance, then we calculate the geometry of the
+      * requested as the plane of the first slice shifted by m_Spacing[3]*s
+      * in the direction of m_DirectionVector.
+      *
+      * \warning The PlaneGeometries are not necessarily up-to-date and not even
+      * initialized.
+      *
+      * The PlaneGeometries have to be initialized in the method
+      * GenerateOutputInformation() of BaseProcess (or CopyInformation /
+      * UpdateOutputInformation of BaseData, if possible, e.g., by analyzing
+      * pic tags in Image) subclasses. See also
+      *
+      * \sa itk::ProcessObject::GenerateOutputInformation(),
+      * \sa itk::DataObject::CopyInformation() and
+      * \sa itk::DataObject::UpdateOutputInformation().
+      */
+      virtual mitk::PlaneGeometry* GetPlaneGeometry( int s ) const;
 
-  /**
-    * \brief Returns the PlaneGeometry of the slice (\a s).
-   *
-    * If (a) m_EvenlySpaced==true, (b) we don't have a PlaneGeometry stored
-   * for the requested slice, and (c) the first slice (s=0)
-   * is a PlaneGeometry instance, then we calculate the geometry of the
-   * requested as the plane of the first slice shifted by m_Spacing[3]*s
-   * in the direction of m_DirectionVector.
-   *
-   * \warning The Geometry2Ds are not necessarily up-to-date and not even
-   * initialized.
-   *
-   * The Geometry2Ds have to be initialized in the method
-   * GenerateOutputInformation() of BaseProcess (or CopyInformation /
-   * UpdateOutputInformation of BaseData, if possible, e.g., by analyzing
-   * pic tags in Image) subclasses. See also
-   *
-   * \sa itk::ProcessObject::GenerateOutputInformation(),
-   * \sa itk::DataObject::CopyInformation() and
-   * \sa itk::DataObject::UpdateOutputInformation().
-   */
-    virtual mitk::PlaneGeometry* GetGeometry2D( int s ) const;
-
-  /**
+    /**
     * \brief Set PlaneGeometry of slice \a s.
-   */
-    virtual bool SetGeometry2D( mitk::PlaneGeometry *geometry2D, int s );
+    */
+    virtual bool SetPlaneGeometry( mitk::PlaneGeometry *geometry2D, int s );
 
-  //##Documentation
-  //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
-  virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
+    //##Documentation
+    //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
+    virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
 
-  virtual const mitk::BoundingBox* GetBoundingBox() const;
+    virtual const mitk::BoundingBox* GetBoundingBox() const;
 
-  /**
-   * \brief Get the number of slices
-   */
-  itkGetConstMacro( Slices, unsigned int );
+    /**
+    * \brief Get the number of slices
+    */
+    itkGetConstMacro( Slices, unsigned int );
 
-  /**
-   * \brief Check whether a slice exists
-   */
-  virtual bool IsValidSlice( int s = 0 ) const;
+    /**
+    * \brief Check whether a slice exists
+    */
+    virtual bool IsValidSlice( int s = 0 ) const;
 
     virtual void SetReferenceGeometry( BaseGeometry *referenceGeometry );
 
-  /**
-   * \brief Set the SliceNavigationController corresponding to this sliced
-   * geometry.
-   *
-   * The SNC needs to be informed when the number of slices in the geometry
-   * changes, which can occur whenthe slices are re-oriented by rotation.
-   */
-  virtual void SetSliceNavigationController(
-    mitk::SliceNavigationController *snc );
-  mitk::SliceNavigationController *GetSliceNavigationController();
-
-  /**
-   * \brief Set/Get whether the SlicedGeometry3D is evenly-spaced
-   * (m_EvenlySpaced)
-   *
+    /**
+    * \brief Set the SliceNavigationController corresponding to this sliced
+    * geometry.
+    *
+    * The SNC needs to be informed when the number of slices in the geometry
+    * changes, which can occur whenthe slices are re-oriented by rotation.
+    */
+    virtual void SetSliceNavigationController(
+      mitk::SliceNavigationController *snc );
+    mitk::SliceNavigationController *GetSliceNavigationController();
+
+    /**
+    * \brief Set/Get whether the SlicedGeometry3D is evenly-spaced
+    * (m_EvenlySpaced)
+    *
     * If (a) m_EvenlySpaced==true, (b) we don't have a PlaneGeometry stored for
-   * the requested slice, and (c) the first slice (s=0) is a PlaneGeometry
-   * instance, then we calculate the geometry of the requested as the plane
-   * of the first slice shifted by m_Spacing.z * s in the direction of
-   * m_DirectionVector.
-   *
-   * \sa GetGeometry2D
-   */
-   itkGetConstMacro(EvenlySpaced, bool);
-
-  virtual void SetEvenlySpaced(bool on = true);
-
-  /**
-   * \brief Set/Get the vector between slices for the evenly-spaced case
-   * (m_EvenlySpaced==true).
-   *
-   * If the direction-vector is (0,0,0) (the default) and the first
-   * 2D geometry is a PlaneGeometry, then the direction-vector will be
-   * calculated from the plane normal.
-   *
-   * \sa m_DirectionVector
-   */
-  virtual void SetDirectionVector(const mitk::Vector3D& directionVector);
-  itkGetConstMacro(DirectionVector, const mitk::Vector3D&);
-
-  virtual itk::LightObject::Pointer InternalClone() const;
-
-  static const std::string SLICES;
-  const static std::string DIRECTION_VECTOR;
-  const static std::string EVENLY_SPACED;
-
-  /**
-   * \brief Tell this instance how many Geometry2Ds it shall manage. Bounding
-   * box and the Geometry2Ds must be set additionally by calling the respective
-   * methods!
-   *
-   * \warning Bounding box and the 2D-geometries must be set additionally: use
-   * SetBounds(), SetGeometry().
-   */
-  virtual void InitializeSlicedGeometry( unsigned int slices );
-
-  /**
-   * \brief Completely initialize this instance as evenly-spaced with slices
+    * the requested slice, and (c) the first slice (s=0) is a PlaneGeometry
+    * instance, then we calculate the geometry of the requested as the plane
+    * of the first slice shifted by m_Spacing.z * s in the direction of
+    * m_DirectionVector.
+    *
+    * \sa GetPlaneGeometry
+    */
+    itkGetConstMacro(EvenlySpaced, bool);
+
+    virtual void SetEvenlySpaced(bool on = true);
+
+    /**
+    * \brief Set/Get the vector between slices for the evenly-spaced case
+    * (m_EvenlySpaced==true).
+    *
+    * If the direction-vector is (0,0,0) (the default) and the first
+    * 2D geometry is a PlaneGeometry, then the direction-vector will be
+    * calculated from the plane normal.
+    *
+    * \sa m_DirectionVector
+    */
+    virtual void SetDirectionVector(const mitk::Vector3D& directionVector);
+    itkGetConstMacro(DirectionVector, const mitk::Vector3D&);
+
+    virtual itk::LightObject::Pointer InternalClone() const;
+
+    static const std::string SLICES;
+    const static std::string DIRECTION_VECTOR;
+    const static std::string EVENLY_SPACED;
+
+    /**
+    * \brief Tell this instance how many PlaneGeometries it shall manage. Bounding
+    * box and the PlaneGeometries must be set additionally by calling the respective
+    * methods!
+    *
+    * \warning Bounding box and the 2D-geometries must be set additionally: use
+    * SetBounds(), SetGeometry().
+    */
+    virtual void InitializeSlicedGeometry( unsigned int slices );
+
+    /**
+    * \brief Completely initialize this instance as evenly-spaced with slices
     * parallel to the provided PlaneGeometry that is used as the first slice and
-   * for spacing calculation.
-   *
-   * Initializes the bounding box according to the width/height of the
+    * for spacing calculation.
+    *
+    * Initializes the bounding box according to the width/height of the
     * PlaneGeometry and \a slices. The spacing is calculated from the PlaneGeometry.
-   */
+    */
     virtual void InitializeEvenlySpaced( mitk::PlaneGeometry *geometry2D,
-    unsigned int slices, bool flipped=false );
+      unsigned int slices, bool flipped=false );
 
-  /**
-   * \brief Completely initialize this instance as evenly-spaced with slices
+    /**
+    * \brief Completely initialize this instance as evenly-spaced with slices
     * parallel to the provided PlaneGeometry that is used as the first slice and
-   * for spacing calculation (except z-spacing).
-   *
-   * Initializes the bounding box according to the width/height of the
+    * for spacing calculation (except z-spacing).
+    *
+    * Initializes the bounding box according to the width/height of the
     * PlaneGeometry and \a slices. The x-/y-spacing is calculated from the
     * PlaneGeometry.
-   */
+    */
     virtual void InitializeEvenlySpaced( mitk::PlaneGeometry *geometry2D,
-    mitk::ScalarType zSpacing, unsigned int slices, bool flipped=false );
-
-  /**
-   * \brief Completely initialize this instance as evenly-spaced plane slices
-   * parallel to a side of the provided Geometry3D and using its spacing
-   * information.
-   *
-   * Initializes the bounding box according to the width/height of the
-   * Geometry3D and the number of slices according to
-   * Geometry3D::GetExtent(2).
-   *
-   * \param planeorientation side parallel to which the slices will be oriented
-   * \param top if \a true, create plane at top, otherwise at bottom
-   * (for PlaneOrientation Axial, for other plane locations respectively)
-   * \param frontside defines the side of the plane (the definition of
-   * front/back is somewhat arbitrary)
-   *
-   * \param rotate rotates the plane by 180 degree around its normal (the
-   * definition of rotated vs not rotated is somewhat arbitrary)
-   */
+      mitk::ScalarType zSpacing, unsigned int slices, bool flipped=false );
+
+    /**
+    * \brief Completely initialize this instance as evenly-spaced plane slices
+    * parallel to a side of the provided BaseGeometry and using its spacing
+    * information.
+    *
+    * Initializes the bounding box according to the width/height of the
+    * BaseGeometry and the number of slices according to
+    * BaseGeometry::GetExtent(2).
+    *
+    * \param planeorientation side parallel to which the slices will be oriented
+    * \param top if \a true, create plane at top, otherwise at bottom
+    * (for PlaneOrientation Axial, for other plane locations respectively)
+    * \param frontside defines the side of the plane (the definition of
+    * front/back is somewhat arbitrary)
+    *
+    * \param rotate rotates the plane by 180 degree around its normal (the
+    * definition of rotated vs not rotated is somewhat arbitrary)
+    */
     virtual void InitializePlanes( const mitk::BaseGeometry *geometry3D,
-    mitk::PlaneGeometry::PlaneOrientation planeorientation, bool top=true,
-    bool frontside=true, bool rotated=false );
+      mitk::PlaneGeometry::PlaneOrientation planeorientation, bool top=true,
+      bool frontside=true, bool rotated=false );
 
-  virtual void SetImageGeometry(const bool isAnImageGeometry);
+    virtual void SetImageGeometry(const bool isAnImageGeometry);
 
-  virtual void ExecuteOperation(Operation* operation);
+    virtual void ExecuteOperation(Operation* operation);
 
-  static double CalculateSpacing( const mitk::Vector3D spacing, const mitk::Vector3D &d );
+    static double CalculateSpacing( const mitk::Vector3D spacing, const mitk::Vector3D &d );
 
   protected:
-  SlicedGeometry3D();
-
-  SlicedGeometry3D(const SlicedGeometry3D& other);
+    SlicedGeometry3D();
 
-  virtual ~SlicedGeometry3D();
+    SlicedGeometry3D(const SlicedGeometry3D& other);
 
-    virtual void PreSetBounds(const BoundsArrayType& bounds){};
-
-    virtual void PostSetTimeBounds( const mitk::TimeBounds& timebounds );
+    virtual ~SlicedGeometry3D();
 
     /**
-    * \brief Set the spacing (m_Spacing), in direction of the plane normal.
+    * Reinitialize plane stack after rotation. More precisely, the first plane
+    * of the stack needs to spatially aligned, in two respects:
     *
-    * INTERNAL METHOD.
+    * 1. Re-alignment with respect to the dataset center; this is necessary
+    *    since the distance from the first plane to the center could otherwise
+    *    continuously decrease or increase.
+    * 2. Re-alignment with respect to a given reference point; the reference
+    *    point is a location which the user wants to be exactly touched by one
+    *    plane of the plane stack. The first plane is minimally shifted to
+    *    ensure this touching. Usually, the reference point would be the
+    *    point around which the geometry is rotated.
     */
-    virtual void PreSetSpacing( const mitk::Vector3D &aSpacing );
-
-  /**
-   * Reinitialize plane stack after rotation. More precisely, the first plane
-   * of the stack needs to spatially aligned, in two respects:
-   *
-   * 1. Re-alignment with respect to the dataset center; this is necessary
-   *    since the distance from the first plane to the center could otherwise
-   *    continuously decrease or increase.
-   * 2. Re-alignment with respect to a given reference point; the reference
-   *    point is a location which the user wants to be exactly touched by one
-   *    plane of the plane stack. The first plane is minimally shifted to
-   *    ensure this touching. Usually, the reference point would be the
-   *    point around which the geometry is rotated.
-   */
-  virtual void ReinitializePlanes( const Point3D &center,
-    const Point3D &referencePoint );
+    virtual void ReinitializePlanes( const Point3D &center,
+      const Point3D &referencePoint );
 
     ScalarType GetLargestExtent( const BaseGeometry *geometry );
 
-  void PrintSelf(std::ostream& os, itk::Indent indent) const;
+    void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
-  /** Calculate "directed spacing", i.e. the spacing in directions
-   * non-orthogonal to the coordinate axes. This is done via the
-   * ellipsoid equation.
-   */
-  double CalculateSpacing( const mitk::Vector3D &direction ) const;
+    /** Calculate "directed spacing", i.e. the spacing in directions
+    * non-orthogonal to the coordinate axes. This is done via the
+    * ellipsoid equation.
+    */
+    double CalculateSpacing( const mitk::Vector3D &direction ) const;
 
-  /** The extent of the slice stack, i.e. the number of slices, depends on the
-   * plane normal. For rotated geometries, the geometry's transform needs to
-   * be accounted in this calculation.
-   */
-  mitk::Vector3D AdjustNormal( const mitk::Vector3D &normal ) const;
+    /** The extent of the slice stack, i.e. the number of slices, depends on the
+    * plane normal. For rotated geometries, the geometry's transform needs to
+    * be accounted in this calculation.
+    */
+    mitk::Vector3D AdjustNormal( const mitk::Vector3D &normal ) const;
 
-  /**
-   * Container for the 2D-geometries contained within this SliceGeometry3D.
-   */
-    mutable std::vector<PlaneGeometry::Pointer> m_Geometry2Ds;
+    /**
+    * Container for the 2D-geometries contained within this SliceGeometry3D.
+    */
+    mutable std::vector<PlaneGeometry::Pointer> m_PlaneGeometries;
 
-  /**
+    /**
     * If (a) m_EvenlySpaced==true, (b) we don't have a PlaneGeometry stored
-   * for the requested slice, and (c) the first slice (s=0)
-   * is a PlaneGeometry instance, then we calculate the geometry of the
-   * requested as the plane of the first slice shifted by m_Spacing.z*s
-   * in the direction of m_DirectionVector.
-   *
-   * \sa GetGeometry2D
-   */
-  bool m_EvenlySpaced;
-
-  /**
-   * Vector between slices for the evenly-spaced case (m_EvenlySpaced==true).
-   * If the direction-vector is (0,0,0) (the default) and the first
-   * 2D geometry is a PlaneGeometry, then the direction-vector will be
-   * calculated from the plane normal.
-   */
-  mutable mitk::Vector3D m_DirectionVector;
-
-  /** Number of slices this SliceGeometry3D is descibing. */
-  unsigned int m_Slices;
-
-  /** Underlying Geometry3D for this SlicedGeometry */
+    * for the requested slice, and (c) the first slice (s=0)
+    * is a PlaneGeometry instance, then we calculate the geometry of the
+    * requested as the plane of the first slice shifted by m_Spacing.z*s
+    * in the direction of m_DirectionVector.
+    *
+    * \sa GetPlaneGeometry
+    */
+    bool m_EvenlySpaced;
+
+    /**
+    * Vector between slices for the evenly-spaced case (m_EvenlySpaced==true).
+    * If the direction-vector is (0,0,0) (the default) and the first
+    * 2D geometry is a PlaneGeometry, then the direction-vector will be
+    * calculated from the plane normal.
+    */
+    mutable mitk::Vector3D m_DirectionVector;
+
+    /** Number of slices this SliceGeometry3D is descibing. */
+    unsigned int m_Slices;
+
+    /** Underlying BaseGeometry for this SlicedGeometry */
     mitk::BaseGeometry *m_ReferenceGeometry;
 
-  /** SNC correcsponding to this geometry; used to reflect changes in the
-   * number of slices due to rotation. */
-  //mitk::NavigationController *m_NavigationController;
-  mitk::SliceNavigationController *m_SliceNavigationController;
+    /** SNC correcsponding to this geometry; used to reflect changes in the
+    * number of slices due to rotation. */
+    //mitk::NavigationController *m_NavigationController;
+    mitk::SliceNavigationController *m_SliceNavigationController;
+  private:
+
+    virtual void PreSetBounds(const BoundsArrayType& bounds){};
+
+    virtual void PostSetTimeBounds( const mitk::TimeBounds& timebounds );
+
+        /**
+    * \brief Set the spacing (m_Spacing), in direction of the plane normal.
+    *
+    */
+    virtual void PreSetSpacing( const mitk::Vector3D &aSpacing );
   };
 } // namespace mitk
 
 #endif /* MITKSLICEDGEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/IO/mitkItkImageFileReader.cpp b/Core/Code/IO/mitkItkImageFileReader.cpp
index 776a82e753..475610eaf1 100644
--- a/Core/Code/IO/mitkItkImageFileReader.cpp
+++ b/Core/Code/IO/mitkItkImageFileReader.cpp
@@ -1,211 +1,211 @@
 /*===================================================================
 
 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 "mitkItkImageFileReader.h"
 #include "mitkConfig.h"
 #include "mitkException.h"
 #include <mitkProportionalTimeGeometry.h>
 
 #include <itkImageFileReader.h>
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 #include <itkImage.h>
 //#include <itkImageSeriesReader.h>
 #include <itkImageFileReader.h>
 #include <itkImageIOFactory.h>
 #include <itkImageIORegion.h>
 //#include <itkImageSeriesReader.h>
 //#include <itkDICOMImageIO2.h>
 //#include <itkDICOMSeriesFileNames.h>
 //#include <itkGDCMImageIO.h>
 //#include <itkGDCMSeriesFileNames.h>
 //#include <itkNumericSeriesFileNames.h>
 
 
 void mitk::ItkImageFileReader::GenerateData()
 {
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO("mitkItkImageFileReader") << "Could not set locale " << locale;
     }
   }
 
   mitk::Image::Pointer image = this->GetOutput();
 
   const unsigned int MINDIM = 2;
   const unsigned int MAXDIM = 4;
 
   MITK_INFO("mitkItkImageFileReader") << "loading " << m_FileName << " via itk::ImageIOFactory... " << std::endl;
 
   // Check to see if we can read the file given the name or prefix
   if ( m_FileName == "" )
   {
     mitkThrow() << "Empty filename in mitk::ItkImageFileReader ";
     return ;
   }
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( m_FileName.c_str(), itk::ImageIOFactory::ReadMode );
   if ( imageIO.IsNull() )
   {
     //itkWarningMacro( << "File Type not supported!" );
     mitkThrow() << "Could not create itk::ImageIOBase object for filename " << m_FileName;
     return ;
   }
 
   // Got to allocate space for the image. Determine the characteristics of
   // the image.
   imageIO->SetFileName( m_FileName.c_str() );
   imageIO->ReadImageInformation();
 
   unsigned int ndim = imageIO->GetNumberOfDimensions();
   if ( ndim < MINDIM || ndim > MAXDIM )
   {
     itkWarningMacro( << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D." );
     ndim = MAXDIM;
   }
 
   itk::ImageIORegion ioRegion( ndim );
   itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
   itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
 
   unsigned int dimensions[ MAXDIM ];
   dimensions[ 0 ] = 0;
   dimensions[ 1 ] = 0;
   dimensions[ 2 ] = 0;
   dimensions[ 3 ] = 0;
 
   ScalarType spacing[ MAXDIM ];
   spacing[ 0 ] = 1.0f;
   spacing[ 1 ] = 1.0f;
   spacing[ 2 ] = 1.0f;
   spacing[ 3 ] = 1.0f;
 
   Point3D origin;
   origin.Fill(0);
 
   unsigned int i;
   for ( i = 0; i < ndim ; ++i )
   {
     ioStart[ i ] = 0;
     ioSize[ i ] = imageIO->GetDimensions( i );
     if(i<MAXDIM)
     {
       dimensions[ i ] = imageIO->GetDimensions( i );
       spacing[ i ] = imageIO->GetSpacing( i );
       if(spacing[ i ] <= 0)
         spacing[ i ] = 1.0f;
     }
     if(i<3)
     {
       origin[ i ] = imageIO->GetOrigin( i );
     }
   }
 
   ioRegion.SetSize( ioSize );
   ioRegion.SetIndex( ioStart );
 
   MITK_INFO("mitkItkImageFileReader") << "ioRegion: " << ioRegion << std::endl;
   imageIO->SetIORegion( ioRegion );
   void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
   imageIO->Read( buffer );
 
   image->Initialize( MakePixelType(imageIO), ndim, dimensions );
   image->SetImportChannel( buffer, 0, Image::ManageMemory );
 
   // access direction of itk::Image and include spacing
   mitk::Matrix3D matrix;
   matrix.SetIdentity();
   unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
   for ( i=0; i < itkDimMax3; ++i)
     for( j=0; j < itkDimMax3; ++j )
       matrix[i][j] = imageIO->GetDirection(j)[i];
 
   // re-initialize PlaneGeometry with origin and direction
-  PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(image->GetSlicedGeometry(0)->GetGeometry2D(0));
+  PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(image->GetSlicedGeometry(0)->GetPlaneGeometry(0));
   planeGeometry->SetOrigin(origin);
   planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
   // re-initialize SlicedGeometry3D
   SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
   slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
   slicedGeometry->SetSpacing(spacing);
 
   MITK_INFO("mitkItkImageFileReader") << slicedGeometry->GetCornerPoint(false,false,false);
   MITK_INFO("mitkItkImageFileReader") << slicedGeometry->GetCornerPoint(true,true,true);
 
   // re-initialize TimeGeometry
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
   image->SetTimeGeometry(timeGeometry);
 
   buffer = NULL;
   MITK_INFO("mitkItkImageFileReader") << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
 //  mitk::DataNode::Pointer node = this->GetOutput();
 //  node->SetData( image );
 
   // add level-window property
   //if ( image->GetPixelType().GetNumberOfComponents() == 1 )
   //{
   //  SetDefaultImageProperties( node );
   //}
   MITK_INFO("mitkItkImageFileReader") << "...finished!" << std::endl;
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO("mitkItkImageFileReader") << "Could not reset locale " << currLocale;
   }
 }
 
 
 bool mitk::ItkImageFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
 {
   // First check the extension
   if(  filename == "" )
     return false;
 
   // check if image is serie
   if( filePattern != "" && filePrefix != "" )
     return false;
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( filename.c_str(), itk::ImageIOFactory::ReadMode );
   if ( imageIO.IsNull() )
     return false;
 
   return true;
 }
 
 mitk::ItkImageFileReader::ItkImageFileReader()
     : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
 }
 
 mitk::ItkImageFileReader::~ItkImageFileReader()
 {
 }
diff --git a/Core/Code/Interactions/mitkCoordinateSupplier.cpp b/Core/Code/Interactions/mitkCoordinateSupplier.cpp
index a18ea3757e..2b69a4372c 100755
--- a/Core/Code/Interactions/mitkCoordinateSupplier.cpp
+++ b/Core/Code/Interactions/mitkCoordinateSupplier.cpp
@@ -1,169 +1,169 @@
 /*===================================================================
 
 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 "mitkDisplayCoordinateOperation.h"
 //has to be on top, otherwise compiler error!
 #include "mitkCoordinateSupplier.h"
 #include "mitkOperation.h"
 #include "mitkOperationActor.h"
 #include "mitkPointOperation.h"
 #include "mitkPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkUndoController.h"
 //and not here!
 #include <string>
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 
 
 mitk::CoordinateSupplier::CoordinateSupplier(const char * type, mitk::OperationActor* operationActor)
 : mitk::StateMachine(type), m_Destination(operationActor)
 {
   m_CurrentPoint.Fill(0);
 }
 
 mitk::CoordinateSupplier::~CoordinateSupplier()
 {
 
 }
 
 bool mitk::CoordinateSupplier::ExecuteAction(Action* action, mitk::StateEvent const* stateEvent)
 {
     bool ok = false;
 
     const PositionEvent* posEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
 
     PointOperation* doOp=NULL;
     if(posEvent!=NULL)
     {
       ScalarType timeInMS = 0;
       if(stateEvent->GetEvent()->GetSender()!=NULL)
       {
-        const PlaneGeometry* worldGeometry = stateEvent->GetEvent()->GetSender()->GetCurrentWorldGeometry2D();
+        const PlaneGeometry* worldGeometry = stateEvent->GetEvent()->GetSender()->GetCurrentWorldPlaneGeometry();
         assert( worldGeometry != NULL );
         timeInMS = worldGeometry->GetTimeBounds()[ 0 ];
       }
       else
       {
         itkWarningMacro(<<"StateEvent::GetSender()==NULL - setting timeInMS to 0");
       }
 
       switch (action->GetActionId())
       {
         case AcNEWPOINT:
         {
           if (m_Destination == NULL)
             return false;
           m_OldPoint = posEvent->GetWorldPosition();
 
           doOp = new mitk::PointOperation(OpADD, timeInMS, m_OldPoint, 0);
           //Undo
           if (m_UndoEnabled)
           {
             PointOperation* undoOp = new PointOperation(OpDELETE, m_OldPoint, 0);
             OperationEvent *operationEvent = new OperationEvent( m_Destination, doOp, undoOp );
             m_UndoController->SetOperationEvent(operationEvent);
           }
           //execute the Operation
           m_Destination->ExecuteOperation(doOp);
 
           if (!m_UndoEnabled)
             delete doOp;
 
           ok = true;
           break;
         }
         case AcINITMOVEMENT:
         {
           if (m_Destination == NULL)
             return false;
           //move the point to the coordinate //not used, cause same to MovePoint... check xml-file
           mitk::Point3D movePoint = posEvent->GetWorldPosition();
 
           mitk::PointOperation doPointOp(OpMOVE, timeInMS, movePoint, 0);
           //execute the Operation
           m_Destination->ExecuteOperation(&doPointOp);
           ok = true;
           break;
         }
         case AcMOVEPOINT:
         case AcMOVE:
         {
           mitk::Point3D movePoint = posEvent->GetWorldPosition();
           m_CurrentPoint = movePoint;
           if (m_Destination == NULL)
             return false;
           mitk::PointOperation doPointOp(OpMOVE, timeInMS, movePoint, 0);
           //execute the Operation
           m_Destination->ExecuteOperation(&doPointOp);
           ok = true;
           break;
         }
         case AcFINISHMOVEMENT:
         {
           if (m_Destination == NULL)
             return false;
           /*finishes a Movement from the coordinate supplier:
           gets the lastpoint from the undolist and writes an undo-operation so
           that the movement of the coordinatesupplier is undoable.*/
           mitk::Point3D movePoint = posEvent->GetWorldPosition();
           mitk::Point3D oldMovePoint; oldMovePoint.Fill(0);
 
           doOp = new mitk::PointOperation(OpMOVE, timeInMS, movePoint, 0);
           PointOperation finishOp(OpTERMINATE, movePoint, 0);
           if (m_UndoEnabled )
           {
             //get the last Position from the UndoList
             OperationEvent *lastOperationEvent = m_UndoController->GetLastOfType(m_Destination, OpMOVE);
             if (lastOperationEvent != NULL)
             {
               PointOperation* lastOp = dynamic_cast<PointOperation *>(lastOperationEvent->GetOperation());
               if (lastOp != NULL)
               {
                 oldMovePoint = lastOp->GetPoint();
               }
             }
             PointOperation* undoOp = new PointOperation(OpMOVE, timeInMS, oldMovePoint, 0, "Move slices");
             OperationEvent *operationEvent = new OperationEvent(m_Destination, doOp, undoOp, "Move slices");
             m_UndoController->SetOperationEvent(operationEvent);
           }
           //execute the Operation
           m_Destination->ExecuteOperation(doOp);
 
           if (!m_UndoEnabled)
             delete doOp;
 
           m_Destination->ExecuteOperation(&finishOp);
           ok = true;
 
           break;
         }
         default:
           ok = false;
           break;
       }
       return ok;
     }
 
     const mitk::DisplayPositionEvent* displPosEvent = dynamic_cast<const mitk::DisplayPositionEvent *>(stateEvent->GetEvent());
     if(displPosEvent!=NULL)
     {
         return true;
     }
 
   return false;
 }
diff --git a/Core/Code/Interactions/mitkInteractor.cpp b/Core/Code/Interactions/mitkInteractor.cpp
index f9b27c0f76..8bc4b95c12 100755
--- a/Core/Code/Interactions/mitkInteractor.cpp
+++ b/Core/Code/Interactions/mitkInteractor.cpp
@@ -1,301 +1,301 @@
 /*===================================================================
 
 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 "mitkInteractor.h"
 #include <mitkDataNode.h>
 #include <mitkDisplayPositionEvent.h>
 #include <mitkPositionEvent.h>
 #include <mitkGeometry3D.h>
 #include <mitkAction.h>
 #include <mitkOperationEvent.h>
 #include <mitkStateEvent.h>
 #include <mitkState.h>
 #include <mitkUndoController.h>
 //#include <mitkStatusBar.h>
 #include <vtkCamera.h>
 #include <vtkRenderer.h>
 #include "mitkInteractionConst.h"
 #include <vtkLinearTransform.h>
 #include <itkVector.h>
 #include <mitkModeOperation.h>
 #include "mitkGlobalInteraction.h"
 
 const std::string mitk::Interactor::XML_NODE_NAME = "interactor";
 
 mitk::Interactor::Interactor(const char * type, DataNode* dataNode)
 : StateMachine(type),
   m_DataNode(dataNode),
   m_Mode(SMDESELECTED)
 {
   if (m_DataNode != NULL)
     m_DataNode->SetInteractor(this);
 
   // handle these actions in those Methods
   CONNECT_ACTION( AcMODEDESELECT,  OnModeDeselect );
   CONNECT_ACTION( AcMODESELECT,    OnModeSelect );
   CONNECT_ACTION( AcMODESUBSELECT, OnModeSubSelect );
 }
 
 mitk::BaseData* mitk::Interactor::GetData() const
 {
   if (m_DataNode != NULL)
     return m_DataNode->GetData();
   else
     return NULL;
 }
 
 mitk::Interactor::SMMode mitk::Interactor::GetMode() const
 {
   return m_Mode;
 }
 
 bool mitk::Interactor::IsNotSelected() const
 {
   return (m_Mode==SMDESELECTED);
 }
 
 bool mitk::Interactor::IsSelected() const
 {
   return (m_Mode!=SMDESELECTED);
 }
 
 void mitk::Interactor::CreateModeOperation(ModeType mode)
 {
   ModeOperation* doOp = new ModeOperation(OpMODECHANGE, mode);
   if (m_UndoEnabled)
   {
     ModeOperation* undoOp = new ModeOperation(OpMODECHANGE, this->GetMode());
     OperationEvent *operationEvent = new OperationEvent(this, doOp, undoOp);
     m_UndoController->SetOperationEvent(operationEvent);
   }
   this->ExecuteOperation(doOp);
 
   if (!m_UndoEnabled)
     delete doOp;
 }
 
 bool mitk::Interactor::OnModeDeselect(Action* /*action*/, StateEvent const*)
 {
   GlobalInteraction* global = GlobalInteraction::GetInstance();
   if (global == NULL)
     itkWarningMacro("Message from Interactor.cpp: GlobalInteraction == NULL! Check use of Interactor!");
 
   if( this->GetMode() !=  SMDESELECTED)
   {
     this->CreateModeOperation(SMDESELECTED);
     global->RemoveFromSelectedInteractors(this);
   }
   return true;
 }
 
 bool mitk::Interactor::OnModeSelect(Action* /*action*/, StateEvent const*)
 {
   GlobalInteraction* global = GlobalInteraction::GetInstance();
   if (global == NULL)
     itkWarningMacro("Message from Interactor.cpp: GlobalInteraction == NULL! Check use of Interactor!");
 
   if( this->GetMode() !=  SMSELECTED)
   {
     this->CreateModeOperation(SMSELECTED);
     global->AddToSelectedInteractors(this);
   }
   return true;
 }
 
 bool mitk::Interactor::OnModeSubSelect(Action* /*action*/, StateEvent const*)
 {
   //StatusBar::GetInstance()->DisplayText("Error! in XML-Interaction: an simple Interactor can not set in sub selected", 1102);
   return false;
 }
 
 float mitk::Interactor::CanHandleEvent(StateEvent const* stateEvent) const
 {
     //return value for boundingbox
   float returnvalueBB = 0.0,
     //return value for a existing transition
     returnvalueTransition = 0.0,
     //return value for an existing key transition
     returnvalueKey = 0.0;
 
   //if it is a key event that can be handled in the current state
   DisplayPositionEvent const  *disPosEvent = dynamic_cast <const DisplayPositionEvent *> (stateEvent->GetEvent());
 
   //Key event handling:
   if (disPosEvent == NULL)
   {
     //check, if the current state has a transition waiting for that key event.
     if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       returnvalueKey = 0.5;
     }
   }
 
   //Mouse event handling:
   //on MouseMove do nothing! reimplement if needed differently
   if (stateEvent->GetEvent()->GetType() == Type_MouseMove)
   {
     return 0;
   }
 
   //if the event can be understood and if there is a transition waiting for that event
   if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
   {
     returnvalueTransition = 0.5;//it can be understood
   }
 
   //compute the center of the data taken care of if != NULL
   if (GetData() != NULL)
   {
 
     DisplayPositionEvent const  *event = dynamic_cast <const DisplayPositionEvent *> (stateEvent->GetEvent());
     if (event != NULL)
     {
       //transforming the world position to local coordinate system
       Point3D point;
 
       GetData()->GetTimeGeometry()->Update();
 
       TimeStepType timeStep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
       GetData()->GetGeometry(timeStep)->WorldToIndex(event->GetWorldPosition(), point);
 
       const BoundingBox *bBox = GetData()->GetGeometry(timeStep)->GetBoundingBox();
       if (bBox == NULL)
         return 0;
 
       //distance between center and point
       BoundingBox::PointType center = bBox->GetCenter();
       returnvalueBB = point.EuclideanDistanceTo(center);
 
       // now check if object bounding box has a non-zero size
       float bBoxSize = bBox->GetMaximum().EuclideanDistanceTo(bBox->GetMinimum() );
       if( bBoxSize < 0.00001 ) return 0;      // bounding box too small?
 
       //now compared to size of bounding box to get value between 0 and 1;
       returnvalueBB = returnvalueBB/bBoxSize;
 
       //safety: if by now return value is not in [0,1], then return 0!
       if (returnvalueBB>1 || returnvalueBB<0)
         returnvalueBB = 0;
 
       // A return value of 1 is good, 0 is bad -> reverse value
       returnvalueBB = 1 - returnvalueBB;
 
       //check if the given position lies inside the data object
       if (bBox->IsInside(point))
       {
         //mapped between 0.5 and 1
         returnvalueBB = 0.5 + (returnvalueBB/ 2);
       }
       else
       {
         //set it in range between 0 and 0.5
         returnvalueBB = returnvalueBB / 2;
       }
     }
   }
   //else
   //  itkWarningMacro("Data of Interactor is NULL! Please check setup of Interactors!");
 
   return std::max(returnvalueBB, std::max(returnvalueKey, returnvalueTransition));
 }
 
 void mitk::Interactor::ExecuteOperation(Operation* operation)
 {
   switch (operation->GetOperationType())
   {
   case OpMODECHANGE:
     {
       ModeOperation *modeOp = dynamic_cast<ModeOperation*>(operation);
       if (modeOp)
       {
         m_Mode = modeOp->GetMode();
       }
     }
     break;
   default:
     Superclass::ExecuteOperation(operation);
   }
 }
 
 const std::string& mitk::Interactor::GetXMLNodeName() const
 {
   return XML_NODE_NAME;
 }
 
 void mitk::Interactor::SetDataNode( DataNode* dataNode )
 {
   m_DataNode = dataNode;
 
   //check for the number of time steps and initialize the vector of CurrentStatePointer accordingly
   if (m_DataNode != NULL)
   {
     mitk::BaseData* data = dataNode->GetData();
     if (data != NULL)
     {
       unsigned int timeSteps = data->GetTimeSteps();
       //expand the list of StartStates according to the number of timesteps in data
       if (timeSteps > 1)
         this->InitializeStartStates(timeSteps);
     }
   }
 }
 
 void mitk::Interactor::UpdateTimeStep(unsigned int timeStep)
 {
   //check if the vector of StartStates contains enough pointers to use timeStep
   if (timeStep >= 1)
   {
     // Make sure that the data (if time-resolved) has enough entries;
     // if not, create the required extra ones (empty)
     if (m_DataNode!= NULL)
       if (m_DataNode->GetData()!= NULL)
         m_DataNode->GetData()->Expand(timeStep+1); //+1 becuase the vector starts with 0 and the timesteps with 1
 
     //now check for this object
     this->ExpandStartStateVector(timeStep+1); //nothing is changed if the number of timesteps in data equals the number of startstates held in statemachine
   }
 
   //set the time to the given time
   Superclass::UpdateTimeStep(timeStep);
 
   //time has to be up-to-date
   //check and throw an exception if not so
   if (timeStep != m_TimeStep)
     itkExceptionMacro(<<"Time is invalid. Take care of synchonization!");
 }
 
 bool mitk::Interactor::HandleEvent(StateEvent const* stateEvent)
 {
   //update the Time and then call Superclass
   if (stateEvent != NULL)
   {
     mitk::Event const* event = stateEvent->GetEvent();
     if (event != NULL)
     {
       mitk::BaseRenderer* sender = event->GetSender();
       if (sender != NULL)
       {
-        //Get the TimeStep according to CurrentWorldGeometry2D
+        //Get the TimeStep according to CurrentWorldPlaneGeometry
         unsigned int currentTimeStep = sender->GetTimeStep();
         if (currentTimeStep != m_TimeStep)
           this->UpdateTimeStep(currentTimeStep);
       }
     }
   }
   return Superclass::HandleEvent(stateEvent);
 }
 
diff --git a/Core/Code/Rendering/mitkBaseRenderer.cpp b/Core/Code/Rendering/mitkBaseRenderer.cpp
index f5093e6188..1d7454239f 100644
--- a/Core/Code/Rendering/mitkBaseRenderer.cpp
+++ b/Core/Code/Rendering/mitkBaseRenderer.cpp
@@ -1,876 +1,876 @@
 /*===================================================================
 
  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 "mitkBaseRenderer.h"
 #include "mitkMapper.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkKeyEvent.h"
 
 // Geometries
 #include "mitkPlaneGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 // Controllers
 #include "mitkCameraController.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkCameraRotationController.h"
 #include "mitkVtkInteractorCameraController.h"
 
 #ifdef MITK_USE_TD_MOUSE
 #include "mitkTDMouseVtkCameraController.h"
 #else
 #include "mitkCameraController.h"
 #endif
 
 #include "mitkVtkLayerController.h"
 
 // Events // TODO: INTERACTION_LEGACY
 #include "mitkEventMapper.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkPositionEvent.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkProperties.h"
 #include "mitkWeakPointerProperty.h"
 #include "mitkInteractionConst.h"
 #include "mitkOverlayManager.h"
 
 // VTK
 #include <vtkLinearTransform.h>
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include <vtkCamera.h>
 
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
 
 mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap;
 
 mitk::BaseRenderer* mitk::BaseRenderer::GetInstance(vtkRenderWindow * renWin)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).first == renWin)
       return (*mapit).second;
   }
   return NULL;
 }
 
 void mitk::BaseRenderer::AddInstance(vtkRenderWindow* renWin, BaseRenderer* baseRenderer)
 {
   if (renWin == NULL || baseRenderer == NULL)
     return;
 
   // ensure that no BaseRenderer is managed twice
   mitk::BaseRenderer::RemoveInstance(renWin);
 
   baseRendererMap.insert(BaseRendererMapType::value_type(renWin, baseRenderer));
 }
 
 void mitk::BaseRenderer::RemoveInstance(vtkRenderWindow* renWin)
 {
   BaseRendererMapType::iterator mapit = baseRendererMap.find(renWin);
   if (mapit != baseRendererMap.end())
     baseRendererMap.erase(mapit);
 }
 
 mitk::BaseRenderer* mitk::BaseRenderer::GetByName(const std::string& name)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).second;
   }
   return NULL;
 }
 
 vtkRenderWindow* mitk::BaseRenderer::GetRenderWindowByName(const std::string& name)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).first;
   }
   return NULL;
 }
 
 mitk::BaseRenderer::BaseRenderer(const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm,RenderingMode::Type renderingMode) :
     m_RenderWindow(NULL), m_VtkRenderer(NULL), m_MapperID(defaultMapper), m_DataStorage(NULL), m_RenderingManager(rm), m_LastUpdateTime(0), m_CameraController(
         NULL), m_SliceNavigationController(NULL), m_CameraRotationController(NULL), /*m_Size(),*/
-    m_Focused(false), m_WorldGeometry(NULL), m_WorldTimeGeometry(NULL), m_CurrentWorldGeometry(NULL), m_CurrentWorldGeometry2D(NULL), m_DisplayGeometry(
-        NULL), m_Slice(0), m_TimeStep(), m_CurrentWorldGeometry2DUpdateTime(), m_DisplayGeometryUpdateTime(), m_TimeStepUpdateTime(), m_WorldGeometryData(
-        NULL), m_DisplayGeometryData(NULL), m_CurrentWorldGeometry2DData(NULL), m_WorldGeometryNode(NULL), m_DisplayGeometryNode(NULL), m_CurrentWorldGeometry2DNode(
-        NULL), m_DisplayGeometryTransformTime(0), m_CurrentWorldGeometry2DTransformTime(0), m_Name(name), /*m_Bounds(),*/m_EmptyWorldGeometry(
+    m_Focused(false), m_WorldGeometry(NULL), m_WorldTimeGeometry(NULL), m_CurrentWorldGeometry(NULL), m_CurrentWorldPlaneGeometry(NULL), m_DisplayGeometry(
+        NULL), m_Slice(0), m_TimeStep(), m_CurrentWorldPlaneGeometryUpdateTime(), m_DisplayGeometryUpdateTime(), m_TimeStepUpdateTime(), m_WorldGeometryData(
+        NULL), m_DisplayGeometryData(NULL), m_CurrentWorldPlaneGeometryData(NULL), m_WorldGeometryNode(NULL), m_DisplayGeometryNode(NULL), m_CurrentWorldPlaneGeometryNode(
+        NULL), m_DisplayGeometryTransformTime(0), m_CurrentWorldPlaneGeometryTransformTime(0), m_Name(name), /*m_Bounds(),*/m_EmptyWorldGeometry(
         true), m_NumberOfVisibleLODEnabledMappers(0)
 {
   m_Bounds[0] = 0;
   m_Bounds[1] = 0;
   m_Bounds[2] = 0;
   m_Bounds[3] = 0;
   m_Bounds[4] = 0;
   m_Bounds[5] = 0;
 
   if (name != NULL)
   {
     m_Name = name;
   }
   else
   {
     m_Name = "unnamed renderer";
     itkWarningMacro(<< "Created unnamed renderer. Bad for serialization. Please choose a name.");
   }
 
   if (renWin != NULL)
   {
     m_RenderWindow = renWin;
     m_RenderWindow->Register(NULL);
   }
   else
   {
     itkWarningMacro(<< "Created mitkBaseRenderer without vtkRenderWindow present.");
   }
 
   m_Size[0] = 0;
   m_Size[1] = 0;
 
   //instances.insert( this );
 
   //adding this BaseRenderer to the List of all BaseRenderer
   // TODO: INTERACTION_LEGACY
   m_RenderingManager->GetGlobalInteraction()->AddFocusElement(this);
 
   m_BindDispatcherInteractor = new mitk::BindDispatcherInteractor( GetName() );
 
   WeakPointerProperty::Pointer rendererProp = WeakPointerProperty::New((itk::Object*) this);
 
-  m_CurrentWorldGeometry2D = mitk::PlaneGeometry::New();
+  m_CurrentWorldPlaneGeometry = mitk::PlaneGeometry::New();
 
-  m_CurrentWorldGeometry2DData = mitk::Geometry2DData::New();
-  m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
-  m_CurrentWorldGeometry2DNode = mitk::DataNode::New();
-  m_CurrentWorldGeometry2DNode->SetData(m_CurrentWorldGeometry2DData);
-  m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("renderer", rendererProp);
-  m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
+  m_CurrentWorldPlaneGeometryData = mitk::PlaneGeometryData::New();
+  m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
+  m_CurrentWorldPlaneGeometryNode = mitk::DataNode::New();
+  m_CurrentWorldPlaneGeometryNode->SetData(m_CurrentWorldPlaneGeometryData);
+  m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
+  m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
 
-  m_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
-  m_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
+  m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
+  m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
 
-  m_CurrentWorldGeometry2DTransformTime = m_CurrentWorldGeometry2DNode->GetVtkTransform()->GetMTime();
+  m_CurrentWorldPlaneGeometryTransformTime = m_CurrentWorldPlaneGeometryNode->GetVtkTransform()->GetMTime();
 
   m_DisplayGeometry = mitk::DisplayGeometry::New();
-  m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
-  m_DisplayGeometryData = mitk::Geometry2DData::New();
-  m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
+  m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldPlaneGeometry);
+  m_DisplayGeometryData = mitk::PlaneGeometryData::New();
+  m_DisplayGeometryData->SetPlaneGeometry(m_DisplayGeometry);
   m_DisplayGeometryNode = mitk::DataNode::New();
   m_DisplayGeometryNode->SetData(m_DisplayGeometryData);
   m_DisplayGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
   m_DisplayGeometryTransformTime = m_DisplayGeometryNode->GetVtkTransform()->GetMTime();
 
   mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::SliceNavigationController::New("navigation");
   sliceNavigationController->SetRenderer(this);
   sliceNavigationController->ConnectGeometrySliceEvent(this);
   sliceNavigationController->ConnectGeometryUpdateEvent(this);
   sliceNavigationController->ConnectGeometryTimeEvent(this, false);
   m_SliceNavigationController = sliceNavigationController;
 
   m_CameraRotationController = mitk::CameraRotationController::New();
   m_CameraRotationController->SetRenderWindow(m_RenderWindow);
   m_CameraRotationController->AcquireCamera();
 
 //if TD Mouse Interaction is activated, then call TDMouseVtkCameraController instead of VtkInteractorCameraController
 #ifdef MITK_USE_TD_MOUSE
   m_CameraController = mitk::TDMouseVtkCameraController::New();
 #else
   m_CameraController = mitk::CameraController::New(NULL);
 #endif
 
   m_VtkRenderer = vtkRenderer::New();
 
   if( renderingMode == RenderingMode::DepthPeeling )
   {
     m_VtkRenderer->SetUseDepthPeeling(1);
     m_VtkRenderer->SetMaximumNumberOfPeels(8);
     m_VtkRenderer->SetOcclusionRatio(0.0);
   }
 
   if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == NULL)
   {
     mitk::VtkLayerController::AddInstance(m_RenderWindow, m_VtkRenderer);
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
   }
   else
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
 }
 
 mitk::BaseRenderer::~BaseRenderer()
 {
   if (m_OverlayManager.IsNotNull())
   {
     m_OverlayManager->RemoveBaseRenderer(this);
   }
 
   if (m_VtkRenderer != NULL)
   {
     m_VtkRenderer->Delete();
     m_VtkRenderer = NULL;
   }
 
   if (m_CameraController.IsNotNull())
     m_CameraController->SetRenderer(NULL);
 
   m_RenderingManager->GetGlobalInteraction()->RemoveFocusElement(this);
 
   mitk::VtkLayerController::RemoveInstance(m_RenderWindow);
 
   RemoveAllLocalStorages();
 
   m_DataStorage = NULL;
 
   if (m_BindDispatcherInteractor != NULL)
   {
     delete m_BindDispatcherInteractor;
   }
 
   if (m_RenderWindow != NULL)
   {
     m_RenderWindow->Delete();
     m_RenderWindow = NULL;
   }
 }
 
 void mitk::BaseRenderer::RemoveAllLocalStorages()
 {
   this->InvokeEvent(mitk::BaseRenderer::RendererResetEvent());
 
   std::list<mitk::BaseLocalStorageHandler*>::iterator it;
   for (it = m_RegisteredLocalStorageHandlers.begin(); it != m_RegisteredLocalStorageHandlers.end(); it++)
     (*it)->ClearLocalStorage(this, false);
   m_RegisteredLocalStorageHandlers.clear();
 }
 
 void mitk::BaseRenderer::RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
 {
   m_RegisteredLocalStorageHandlers.push_back(lsh);
 }
 
 mitk::Dispatcher::Pointer mitk::BaseRenderer::GetDispatcher() const
 {
   return m_BindDispatcherInteractor->GetDispatcher();
 }
 
 mitk::Point3D mitk::BaseRenderer::Map2DRendererPositionTo3DWorldPosition(const Point2D& mousePosition) const
 {
   Point2D p_mm;
   Point3D position;
 
   if (m_MapperID == 1)
   {
     GetDisplayGeometry()->DisplayToWorld(mousePosition, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
   }
   else if (m_MapperID == 2)
   {
     PickWorldPoint(mousePosition, position);
   }
   return position;
 }
 
 void mitk::BaseRenderer::UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
 {
   m_RegisteredLocalStorageHandlers.remove(lsh);
 }
 
 void mitk::BaseRenderer::SetDataStorage(DataStorage* storage)
 {
   if (storage != NULL)
   {
     m_DataStorage = storage;
     m_BindDispatcherInteractor->SetDataStorage(m_DataStorage);
     this->Modified();
   }
 }
 
 const mitk::BaseRenderer::MapperSlotId mitk::BaseRenderer::defaultMapper = 1;
 
 void mitk::BaseRenderer::Paint()
 {
 }
 
 void mitk::BaseRenderer::Initialize()
 {
 }
 
 void mitk::BaseRenderer::Resize(int w, int h)
 {
   m_Size[0] = w;
   m_Size[1] = h;
 
   if (m_CameraController)
     m_CameraController->Resize(w, h); //(formerly problematic on windows: vtkSizeBug)
 
   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h);
 }
 
 void mitk::BaseRenderer::InitRenderer(vtkRenderWindow* renderwindow)
 {
   if (m_RenderWindow != NULL)
   {
     m_RenderWindow->Delete();
   }
   m_RenderWindow = renderwindow;
   if (m_RenderWindow != NULL)
   {
     m_RenderWindow->Register(NULL);
   }
 
   RemoveAllLocalStorages();
 
   if (m_CameraController.IsNotNull())
   {
     m_CameraController->SetRenderer(this);
   }
 }
 
 void mitk::BaseRenderer::InitSize(int w, int h)
 {
   m_Size[0] = w;
   m_Size[1] = h;
   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h, false);
   GetDisplayGeometry()->Fit();
 }
 
 void mitk::BaseRenderer::SetSlice(unsigned int slice)
 {
   if (m_Slice != slice)
   {
     m_Slice = slice;
     if (m_WorldTimeGeometry.IsNotNull())
     {
       SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
         if (m_Slice >= slicedWorldGeometry->GetSlices())
           m_Slice = slicedWorldGeometry->GetSlices() - 1;
-        SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
+        SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 void mitk::BaseRenderer::SetOverlayManager(itk::SmartPointer<OverlayManager> overlayManager)
 {
   if(overlayManager.IsNull())
     return;
 
   if(this->m_OverlayManager.IsNotNull())
   {
     if(this->m_OverlayManager.GetPointer() == overlayManager.GetPointer())
     {
       return;
     }
     else
     {
       this->m_OverlayManager->RemoveBaseRenderer(this);
     }
   }
   this->m_OverlayManager = overlayManager;
   this->m_OverlayManager->AddBaseRenderer(this); //TODO
 }
 
 itk::SmartPointer<mitk::OverlayManager> mitk::BaseRenderer::GetOverlayManager()
 {
   if(this->m_OverlayManager.IsNull())
   {
     m_OverlayManager = mitk::OverlayManager::New();
     m_OverlayManager->AddBaseRenderer(this);
   }
   return this->m_OverlayManager;
 }
 
 void mitk::BaseRenderer::SetTimeStep(unsigned int timeStep)
 {
   if (m_TimeStep != timeStep)
   {
     m_TimeStep = timeStep;
     m_TimeStepUpdateTime.Modified();
 
     if (m_WorldTimeGeometry.IsNotNull())
     {
       if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
         m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
       SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
-        SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
+        SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 int mitk::BaseRenderer::GetTimeStep(const mitk::BaseData* data) const
 {
   if ((data == NULL) || (data->IsInitialized() == false))
   {
     return -1;
   }
   return data->GetTimeGeometry()->TimePointToTimeStep(GetTime());
 }
 
 mitk::ScalarType mitk::BaseRenderer::GetTime() const
 {
   if (m_WorldTimeGeometry.IsNull())
   {
     return 0;
   }
   else
   {
     ScalarType timeInMS = m_WorldTimeGeometry->TimeStepToTimePoint(GetTimeStep());
     if (timeInMS == ScalarTypeNumericTraits::NonpositiveMin())
       return 0;
     else
       return timeInMS;
   }
 }
 
 void mitk::BaseRenderer::SetWorldTimeGeometry(mitk::TimeGeometry* geometry)
 {
   assert(geometry != NULL);
 
   itkDebugMacro("setting WorldTimeGeometry to " << geometry);
   if (m_WorldTimeGeometry != geometry)
   {
     if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldTimeGeometry = geometry;
     itkDebugMacro("setting WorldTimeGeometry to " << m_WorldTimeGeometry);
 
     if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
         m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
 
     BaseGeometry* geometry3d;
     geometry3d = m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep);
     SetWorldGeometry3D(geometry3d);
   }
 }
 
 void mitk::BaseRenderer::SetWorldGeometry3D(mitk::BaseGeometry* geometry)
 {
   itkDebugMacro("setting WorldGeometry3D to " << geometry);
 
   if (m_WorldGeometry != geometry)
   {
     if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldGeometry = geometry;
     SlicedGeometry3D* slicedWorldGeometry;
     slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(geometry);
 
     PlaneGeometry::Pointer geometry2d;
     if (slicedWorldGeometry != NULL)
     {
       if (m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
         m_Slice = slicedWorldGeometry->GetSlices() - 1;
-      geometry2d = slicedWorldGeometry->GetGeometry2D(m_Slice);
+      geometry2d = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
         plane->InitializeStandardPlane(slicedWorldGeometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(slicedWorldGeometry);
     }
     else
     {
       geometry2d = dynamic_cast<PlaneGeometry*>(geometry);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = PlaneGeometry::New();
         plane->InitializeStandardPlane(geometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(geometry);
     }
-    SetCurrentWorldGeometry2D(geometry2d); // calls Modified()
+    SetCurrentWorldPlaneGeometry(geometry2d); // calls Modified()
   }
-  if (m_CurrentWorldGeometry2D.IsNull())
-    itkWarningMacro("m_CurrentWorldGeometry2D is NULL");
+  if (m_CurrentWorldPlaneGeometry.IsNull())
+    itkWarningMacro("m_CurrentWorldPlaneGeometry is NULL");
 }
 
 void mitk::BaseRenderer::SetDisplayGeometry(mitk::DisplayGeometry* geometry2d)
 {
   itkDebugMacro("setting DisplayGeometry to " << geometry2d);
   if (m_DisplayGeometry != geometry2d)
   {
     m_DisplayGeometry = geometry2d;
-    m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
+    m_DisplayGeometryData->SetPlaneGeometry(m_DisplayGeometry);
     m_DisplayGeometryUpdateTime.Modified();
     Modified();
   }
 }
 
-void mitk::BaseRenderer::SetCurrentWorldGeometry2D(mitk::PlaneGeometry* geometry2d)
+void mitk::BaseRenderer::SetCurrentWorldPlaneGeometry(mitk::PlaneGeometry* geometry2d)
 {
-  if (m_CurrentWorldGeometry2D != geometry2d)
+  if (m_CurrentWorldPlaneGeometry != geometry2d)
   {
-    m_CurrentWorldGeometry2D = geometry2d;
-    m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
-    m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
-    m_CurrentWorldGeometry2DUpdateTime.Modified();
+    m_CurrentWorldPlaneGeometry = geometry2d;
+    m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
+    m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldPlaneGeometry);
+    m_CurrentWorldPlaneGeometryUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SendUpdateSlice()
 {
   m_DisplayGeometryUpdateTime.Modified();
-  m_CurrentWorldGeometry2DUpdateTime.Modified();
+  m_CurrentWorldPlaneGeometryUpdateTime.Modified();
 }
 
 void mitk::BaseRenderer::SetCurrentWorldGeometry(mitk::BaseGeometry* geometry)
 {
   m_CurrentWorldGeometry = geometry;
   if (geometry == NULL)
   {
     m_Bounds[0] = 0;
     m_Bounds[1] = 0;
     m_Bounds[2] = 0;
     m_Bounds[3] = 0;
     m_Bounds[4] = 0;
     m_Bounds[5] = 0;
     m_EmptyWorldGeometry = true;
     return;
   }
   BoundingBox::Pointer boundingBox = m_CurrentWorldGeometry->CalculateBoundingBoxRelativeToTransform(NULL);
   const BoundingBox::BoundsArrayType& worldBounds = boundingBox->GetBounds();
   m_Bounds[0] = worldBounds[0];
   m_Bounds[1] = worldBounds[1];
   m_Bounds[2] = worldBounds[2];
   m_Bounds[3] = worldBounds[3];
   m_Bounds[4] = worldBounds[4];
   m_Bounds[5] = worldBounds[5];
   if (boundingBox->GetDiagonalLength2() <= mitk::eps)
     m_EmptyWorldGeometry = true;
   else
     m_EmptyWorldGeometry = false;
 }
 
 void mitk::BaseRenderer::UpdateOverlays()
 {
   if(m_OverlayManager.IsNotNull())
   {
     m_OverlayManager->UpdateOverlays(this);
   }
 }
 
 void mitk::BaseRenderer::SetGeometry(const itk::EventObject & geometrySendEvent)
 {
   const SliceNavigationController::GeometrySendEvent* sendEvent =
       dynamic_cast<const SliceNavigationController::GeometrySendEvent *>(&geometrySendEvent);
 
   assert(sendEvent!=NULL);
   SetWorldTimeGeometry(sendEvent->GetTimeGeometry());
 }
 
 void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject & geometryUpdateEvent)
 {
   const SliceNavigationController::GeometryUpdateEvent* updateEvent =
       dynamic_cast<const SliceNavigationController::GeometryUpdateEvent*>(&geometryUpdateEvent);
 
   if (updateEvent == NULL)
     return;
 
   if (m_CurrentWorldGeometry.IsNotNull())
   {
     SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_CurrentWorldGeometry.GetPointer());
     if (slicedWorldGeometry)
     {
-      PlaneGeometry* geometry2D = slicedWorldGeometry->GetGeometry2D(m_Slice);
+      PlaneGeometry* geometry2D = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
 
-      SetCurrentWorldGeometry2D(geometry2D); // calls Modified()
+      SetCurrentWorldPlaneGeometry(geometry2D); // calls Modified()
     }
   }
 }
 
 void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
 {
   const SliceNavigationController::GeometrySliceEvent* sliceEvent =
       dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
 
   assert(sliceEvent!=NULL);
   SetSlice(sliceEvent->GetPos());
 }
 
 void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject & geometryTimeEvent)
 {
   const SliceNavigationController::GeometryTimeEvent * timeEvent =
       dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
 
   assert(timeEvent!=NULL);
   SetTimeStep(timeEvent->GetPos());
 }
 
 const double* mitk::BaseRenderer::GetBounds() const
 {
   return m_Bounds;
 }
 
 void mitk::BaseRenderer::MousePressEvent(mitk::MouseEvent *me)
 {
   //set the Focus on the renderer
   /*bool success =*/m_RenderingManager->GetGlobalInteraction()->SetFocus(this);
   /*
    if (! success)
    mitk::StatusBar::GetInstance()->DisplayText("Warning! from mitkBaseRenderer.cpp: Couldn't focus this BaseRenderer!");
    */
 
   //if (m_CameraController)
   //{
   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MousePressEvent(me);
   //}
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID > 1)  //==2 for 3D and ==5 for stencil
   {
     Point2D p(me->GetDisplayPosition());
 
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::MouseReleaseEvent(mitk::MouseEvent *me)
 {
   //if (m_CameraController)
   //{
   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MouseReleaseEvent(me);
   //}
 
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(me->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::MouseMoveEvent(mitk::MouseEvent *me)
 {
   //if (m_CameraController)
   //{
   //  if((me->GetButtonState()<=512) || (me->GetButtonState()>=516))// provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MouseMoveEvent(me);
   //}
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(me->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
 {
   mitk::Point2D worldPoint2D;
   GetDisplayGeometry()->DisplayToWorld(displayPoint, worldPoint2D);
   GetDisplayGeometry()->Map(worldPoint2D, worldPoint);
 }
 
 void mitk::BaseRenderer::WheelEvent(mitk::WheelEvent * we)
 {
   if (m_MapperID == 1)
   {
     Point2D p(we->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, we->GetType(), we->GetButton(), we->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(we->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     we->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::KeyPressEvent(mitk::KeyEvent *ke)
 {
   if (m_MapperID == 1)
   {
     Point2D p(ke->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::KeyEvent event(this, ke->GetType(), ke->GetButton(), ke->GetButtonState(), ke->GetKey(), ke->GetText(), p);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(ke->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     ke->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(ke, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::DrawOverlayMouse(mitk::Point2D& itkNotUsed(p2d))
 {
   MITK_INFO<<"BaseRenderer::DrawOverlayMouse()- should be inconcret implementation OpenGLRenderer."<<std::endl;
 }
 
 void mitk::BaseRenderer::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(this->m_RenderWindow);
 }
 
 void mitk::BaseRenderer::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(this->m_RenderWindow);
 }
 
 unsigned int mitk::BaseRenderer::GetNumberOfVisibleLODEnabledMappers() const
 {
   return m_NumberOfVisibleLODEnabledMappers;
 }
 
 mitk::RenderingManager* mitk::BaseRenderer::GetRenderingManager() const
 {
   return m_RenderingManager.GetPointer();
 }
 
 /*!
  Sets the new Navigation controller
  */
 void mitk::BaseRenderer::SetSliceNavigationController(mitk::SliceNavigationController *SlicenavigationController)
 {
   if (SlicenavigationController == NULL)
     return;
 
   //disconnect old from globalinteraction
   m_RenderingManager->GetGlobalInteraction()->RemoveListener(SlicenavigationController);
 
   //copy worldgeometry
   SlicenavigationController->SetInputWorldTimeGeometry(SlicenavigationController->GetCreatedWorldGeometry());
   SlicenavigationController->Update();
 
   //set new
   m_SliceNavigationController = SlicenavigationController;
   m_SliceNavigationController->SetRenderer(this);
 
   if (m_SliceNavigationController.IsNotNull())
   {
     m_SliceNavigationController->ConnectGeometrySliceEvent(this);
     m_SliceNavigationController->ConnectGeometryUpdateEvent(this);
     m_SliceNavigationController->ConnectGeometryTimeEvent(this, false);
   }
 }
 
 /*!
  Sets the new camera controller and deletes the vtkRenderWindowInteractor in case of the VTKInteractorCameraController
  */
 void mitk::BaseRenderer::SetCameraController(CameraController* cameraController)
 {
   mitk::VtkInteractorCameraController::Pointer vtkInteractorCameraController =
       dynamic_cast<mitk::VtkInteractorCameraController*>(cameraController);
   if (vtkInteractorCameraController.IsNotNull())
     MITK_INFO<<"!!!WARNING!!!: RenderWindow interaction events are no longer handled via CameraController (See Bug #954)."<<std::endl;
   m_CameraController->SetRenderer(NULL);
   m_CameraController = NULL;
   m_CameraController = cameraController;
   m_CameraController->SetRenderer(this);
 }
 
 void mitk::BaseRenderer::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " MapperID: " << m_MapperID << std::endl;
   os << indent << " Slice: " << m_Slice << std::endl;
   os << indent << " TimeStep: " << m_TimeStep << std::endl;
 
   os << indent << " WorldGeometry: ";
   if (m_WorldGeometry.IsNull())
     os << "NULL" << std::endl;
   else
     m_WorldGeometry->Print(os, indent);
 
-  os << indent << " CurrentWorldGeometry2D: ";
-  if (m_CurrentWorldGeometry2D.IsNull())
+  os << indent << " CurrentWorldPlaneGeometry: ";
+  if (m_CurrentWorldPlaneGeometry.IsNull())
     os << "NULL" << std::endl;
   else
-    m_CurrentWorldGeometry2D->Print(os, indent);
+    m_CurrentWorldPlaneGeometry->Print(os, indent);
 
-  os << indent << " CurrentWorldGeometry2DUpdateTime: " << m_CurrentWorldGeometry2DUpdateTime << std::endl;
-  os << indent << " CurrentWorldGeometry2DTransformTime: " << m_CurrentWorldGeometry2DTransformTime << std::endl;
+  os << indent << " CurrentWorldPlaneGeometryUpdateTime: " << m_CurrentWorldPlaneGeometryUpdateTime << std::endl;
+  os << indent << " CurrentWorldPlaneGeometryTransformTime: " << m_CurrentWorldPlaneGeometryTransformTime << std::endl;
 
   os << indent << " DisplayGeometry: ";
   if (m_DisplayGeometry.IsNull())
     os << "NULL" << std::endl;
   else
     m_DisplayGeometry->Print(os, indent);
 
   os << indent << " DisplayGeometryTransformTime: " << m_DisplayGeometryTransformTime << std::endl;
   Superclass::PrintSelf(os, indent);
 }
diff --git a/Core/Code/Rendering/mitkBaseRenderer.h b/Core/Code/Rendering/mitkBaseRenderer.h
index 697e750a99..9bee93412d 100644
--- a/Core/Code/Rendering/mitkBaseRenderer.h
+++ b/Core/Code/Rendering/mitkBaseRenderer.h
@@ -1,646 +1,646 @@
 /*===================================================================
 
  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 BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 #define BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 
 #include "mitkDataStorage.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkTimeGeometry.h"
 #include "mitkDisplayGeometry.h"
-#include "mitkGeometry2DData.h"
+#include "mitkPlaneGeometryData.h"
 #include "mitkCameraController.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkWheelEvent.h"
 
 //#include "mitkMapper.h"
 
 #include "mitkSliceNavigationController.h"
 #include "mitkCameraController.h"
 #include "mitkCameraRotationController.h"
 
 #include "mitkBindDispatcherInteractor.h"
 #include "mitkDispatcher.h"
 
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 
 #include <map>
 #include <set>
 
 // DEPRECATED
 #include <mitkTimeSlicedGeometry.h>
 
 namespace mitk
 {
   class NavigationController;
   class SliceNavigationController;
   class CameraRotationController;
   class CameraController;
   class DataStorage;
   class Mapper;
   class BaseLocalStorageHandler;
   class OverlayManager;
 
 //##Documentation
 //## @brief Organizes the rendering process
 //##
 //## Organizes the rendering process. A Renderer contains a reference to a
 //## DataStorage and asks the mappers of the data objects to render
 //## the data into the renderwindow it is associated to.
 //##
 //## \#Render() checks if rendering is currently allowed by calling
 //## RenderWindow::PrepareRendering(). Initialization of a rendering context
 //## can also be performed in this method.
 //##
 //## The actual rendering code has been moved to \#Repaint()
 //## Both \#Repaint() and \#Update() are declared protected now.
 //##
 //## Note: Separation of the Repaint and Update processes (rendering vs
 //## creating a vtk prop tree) still needs to be worked on. The whole
 //## rendering process also should be reworked to use VTK based classes for
 //## both 2D and 3D rendering.
 //## @ingroup Renderer
   class MITK_CORE_EXPORT BaseRenderer: public itk::Object
   {
   public:
 
     /** \brief This rendering mode enumeration is specified at various constructors
     *  of the Renderer and RenderWindow classes, which autoconfigures the
     *  respective VTK objects. This has to be done at construction time because later
     *  configuring turns out to be not working on most platforms.
     */
     struct RenderingMode
     {
       enum Type {
         Standard = 0,  // no multi-sampling, no depth-peeling
         MultiSampling, // multi-sampling (antialiasing), no depth-peeling
         DepthPeeling   // no multi-sampling, depth-peeling is on (order-independant transparency)
       };
     };
 
     typedef std::map<vtkRenderWindow*, BaseRenderer*> BaseRendererMapType;
     static BaseRendererMapType baseRendererMap;
 
     static BaseRenderer* GetInstance(vtkRenderWindow * renWin);
     static void AddInstance(vtkRenderWindow* renWin, BaseRenderer* baseRenderer);
     static void RemoveInstance(vtkRenderWindow* renWin);
 
     static BaseRenderer* GetByName(const std::string& name);
     static vtkRenderWindow* GetRenderWindowByName(const std::string& name);
 
 #pragma GCC visibility push(default)
     itkEventMacro( RendererResetEvent, itk::AnyEvent );
 #pragma GCC visibility pop
 
     /** Standard class typedefs. */
     mitkClassMacro(BaseRenderer, itk::Object);
 
     BaseRenderer(const char* name = NULL, vtkRenderWindow * renWin = NULL, mitk::RenderingManager* rm = NULL,RenderingMode::Type mode = RenderingMode::Standard);
 
     //##Documentation
     //## @brief MapperSlotId defines which kind of mapper (e.g., 2D or 3D) shoud be used.
     typedef int MapperSlotId;
 
     enum StandardMapperSlot
     {
       Standard2D = 1, Standard3D = 2
     };
 
     virtual void SetDataStorage(DataStorage* storage);  ///< set the datastorage that will be used for rendering
 
     //##Documentation
     //## return the DataStorage that is used for rendering
     virtual DataStorage::Pointer GetDataStorage() const
     {
       return m_DataStorage.GetPointer();
     }
 
     //##Documentation
     //## @brief Access the RenderWindow into which this renderer renders.
     vtkRenderWindow* GetRenderWindow() const
     {
       return m_RenderWindow;
     }
     vtkRenderer* GetVtkRenderer() const
     {
       return m_VtkRenderer;
     }
 
     //##Documentation
     //## @brief Returns the Dispatcher which handles Events for this BaseRenderer
     Dispatcher::Pointer GetDispatcher() const;
 
     //##Documentation
     //## @brief Default mapper id to use.
     static const MapperSlotId defaultMapper;
 
     //##Documentation
     //## @brief Do the rendering and flush the result.
     virtual void Paint();
 
     //##Documentation
     //## @brief Initialize the RenderWindow. Should only be called from RenderWindow.
     virtual void Initialize();
 
     //##Documentation
     //## @brief Called to inform the renderer that the RenderWindow has been resized.
     virtual void Resize(int w, int h);
 
     //##Documentation
     //## @brief Initialize the renderer with a RenderWindow (@a renderwindow).
     virtual void InitRenderer(vtkRenderWindow* renderwindow);
 
     //##Documentation
     //## @brief Set the initial size. Called by RenderWindow after it has become
     //## visible for the first time.
     virtual void InitSize(int w, int h);
 
     //##Documentation
     //## @brief Draws a point on the widget.
     //## Should be used during conferences to show the position of the remote mouse
     virtual void DrawOverlayMouse(Point2D& p2d);
 
     //##Documentation
     //## @brief Set/Get the WorldGeometry (m_WorldGeometry) for 3D and 2D rendering, that describing the
     //## (maximal) area to be rendered.
     //##
-    //## Depending of the type of the passed Geometry3D more or less information can be extracted:
-    //## \li if it is a PlaneGeometry (which is a sub-class of Geometry3D), m_CurrentWorldGeometry2D is
+    //## Depending of the type of the passed BaseGeometry more or less information can be extracted:
+    //## \li if it is a PlaneGeometry (which is a sub-class of BaseGeometry), m_CurrentWorldPlaneGeometry is
     //## also set to point to it. m_WorldTimeGeometry is set to NULL.
     //## \li if it is a TimeGeometry, m_WorldTimeGeometry is also set to point to it.
-    //## If m_WorldTimeGeometry contains instances of SlicedGeometry3D, m_CurrentWorldGeometry2D is set to
+    //## If m_WorldTimeGeometry contains instances of SlicedGeometry3D, m_CurrentWorldPlaneGeometry is set to
     //## one of geometries stored in the SlicedGeometry3D according to the value of m_Slice;  otherwise
-    //## a PlaneGeometry describing the top of the bounding-box of the Geometry3D is set as the
-    //## m_CurrentWorldGeometry2D.
-    //## \li otherwise a PlaneGeometry describing the top of the bounding-box of the Geometry3D
-    //## is set as the m_CurrentWorldGeometry2D. m_WorldTimeGeometry is set to NULL.
-    //## @todo add calculation of PlaneGeometry describing the top of the bounding-box of the Geometry3D
-    //## when the passed Geometry3D is not sliced.
+    //## a PlaneGeometry describing the top of the bounding-box of the BaseGeometry is set as the
+    //## m_CurrentWorldPlaneGeometry.
+    //## \li otherwise a PlaneGeometry describing the top of the bounding-box of the BaseGeometry
+    //## is set as the m_CurrentWorldPlaneGeometry. m_WorldTimeGeometry is set to NULL.
+    //## @todo add calculation of PlaneGeometry describing the top of the bounding-box of the BaseGeometry
+    //## when the passed BaseGeometry is not sliced.
     //## \sa m_WorldGeometry
     //## \sa m_WorldTimeGeometry
-    //## \sa m_CurrentWorldGeometry2D
+    //## \sa m_CurrentWorldPlaneGeometry
     virtual void SetWorldGeometry3D(BaseGeometry* geometry);
     virtual void SetWorldTimeGeometry(mitk::TimeGeometry* geometry);
 
     /**
     * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(void SetWorldGeometry3D(TimeSlicedGeometry* geometry));
 
     itkGetConstObjectMacro(WorldGeometry, BaseGeometry)
     itkGetObjectMacro(WorldGeometry, BaseGeometry)
     itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry)
     itkGetObjectMacro(WorldTimeGeometry, TimeGeometry)
 
     //##Documentation
     //## @brief Get the current 3D-worldgeometry (m_CurrentWorldGeometry) used for 3D-rendering
     itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry)
 
     //##Documentation
-    //## @brief Get the current 2D-worldgeometry (m_CurrentWorldGeometry2D) used for 2D-rendering
-    itkGetConstObjectMacro(CurrentWorldGeometry2D, PlaneGeometry)
+    //## @brief Get the current 2D-worldgeometry (m_CurrentWorldPlaneGeometry) used for 2D-rendering
+    itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry)
 
     //##Documentation
     //## Calculates the bounds of the DataStorage (if it contains any valid data),
     //## creates a geometry from these bounds and sets it as world geometry of the renderer.
     //##
     //## Call this method to re-initialize the renderer to the current DataStorage
     //## (e.g. after loading an additional dataset), to ensure that the view is
     //## aligned correctly.
     //## \warn This is not implemented yet.
     virtual bool SetWorldGeometryToDataStorageBounds()
     {
       return false;
     }
 
     //##Documentation
     //## @brief Set/Get the DisplayGeometry (for 2D rendering)
     //##
-    //## The DisplayGeometry describes which part of the PlaneGeometry m_CurrentWorldGeometry2D
+    //## The DisplayGeometry describes which part of the PlaneGeometry m_CurrentWorldPlaneGeometry
     //## is displayed.
     virtual void SetDisplayGeometry(DisplayGeometry* geometry2d);
 
     itkGetConstObjectMacro(DisplayGeometry, DisplayGeometry)
     itkGetObjectMacro(DisplayGeometry, DisplayGeometry)
 
     //##Documentation
     //## @brief Set/Get m_Slice which defines together with m_TimeStep the 2D geometry
-    //## stored in m_WorldTimeGeometry used as m_CurrentWorldGeometry2D
+    //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
     //##
     //## \sa m_Slice
     virtual void SetSlice(unsigned int slice);
 
     //##Documentation
     //## @brief Sets an OverlayManager which is used to add various Overlays to this
     //## renderer. If an OverlayManager was already set it will be overwritten.
     void SetOverlayManager(itk::SmartPointer<OverlayManager> overlayManager);
 
     //##Documentation
     //## @brief Get the OverlayManager registered with this renderer
     //## if none was set, it will be created at this point.
     itk::SmartPointer<OverlayManager> GetOverlayManager();
 
     itkGetConstMacro(Slice, unsigned int)
 
     //##Documentation
     //## @brief Set/Get m_TimeStep which defines together with m_Slice the 2D geometry
-    //## stored in m_WorldTimeGeometry used as m_CurrentWorldGeometry2D
+    //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
     //##
     //## \sa m_TimeStep
     virtual void SetTimeStep(unsigned int timeStep);
 
     itkGetConstMacro(TimeStep, unsigned int)
 
     //##Documentation
     //## @brief Get the time-step of a BaseData object which
     //## exists at the time of the currently displayed content
     //##
     //## Returns -1 or mitk::BaseData::m_TimeSteps if there
     //## is no data at the current time.
     //## \sa GetTimeStep, m_TimeStep
     int GetTimeStep(const BaseData* data) const;
 
     //##Documentation
     //## @brief Get the time in ms of the currently displayed content
     //##
     //## \sa GetTimeStep, m_TimeStep
     ScalarType GetTime() const;
 
     //##Documentation
     //## @brief SetWorldGeometry is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySendEvent
     virtual void SetGeometry(const itk::EventObject & geometrySliceEvent);
 
     //##Documentation
     //## @brief UpdateWorldGeometry is called to re-read the 2D geometry from the
     //## slice navigation controller
     virtual void UpdateGeometry(const itk::EventObject & geometrySliceEvent);
 
     //##Documentation
     //## @brief SetSlice is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySliceEvent
     virtual void SetGeometrySlice(const itk::EventObject & geometrySliceEvent);
 
     //##Documentation
     //## @brief SetTimeStep is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometryTimeEvent
     virtual void SetGeometryTime(const itk::EventObject & geometryTimeEvent);
 
     //##Documentation
     //## @brief Get a data object containing the DisplayGeometry (for 2D rendering)
-    itkGetObjectMacro(DisplayGeometryData, Geometry2DData)
+    itkGetObjectMacro(DisplayGeometryData, PlaneGeometryData)
     //##Documentation
     //## @brief Get a data object containing the WorldGeometry (for 2D rendering)
-    itkGetObjectMacro(WorldGeometryData, Geometry2DData)
+    itkGetObjectMacro(WorldGeometryData, PlaneGeometryData)
 
     //##Documentation
     //## @brief Get a DataNode pointing to a data object containing the WorldGeometry (3D and 2D rendering)
     itkGetObjectMacro(WorldGeometryNode, DataNode)
     //##Documentation
     //## @brief Get a DataNode pointing to a data object containing the DisplayGeometry (for 2D rendering)
     itkGetObjectMacro(DisplayGeometryNode, DataNode)
     //##Documentation
-    //## @brief Get a DataNode pointing to a data object containing the current 2D-worldgeometry m_CurrentWorldGeometry2D (for 2D rendering)
-    itkGetObjectMacro(CurrentWorldGeometry2DNode, DataNode)
+    //## @brief Get a DataNode pointing to a data object containing the current 2D-worldgeometry m_CurrentWorldPlaneGeometry (for 2D rendering)
+    itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode)
 
     //##Documentation
-    //## @brief Sets timestamp of CurrentWorldGeometry2D and DisplayGeometry and forces so reslicing in that renderwindow
+    //## @brief Sets timestamp of CurrentWorldPlaneGeometry and DisplayGeometry and forces so reslicing in that renderwindow
     void SendUpdateSlice();
 
     //##Documentation
-    //## @brief Get timestamp of last call of SetCurrentWorldGeometry2D
-    unsigned long GetCurrentWorldGeometry2DUpdateTime()
+    //## @brief Get timestamp of last call of SetCurrentWorldPlaneGeometry
+    unsigned long GetCurrentWorldPlaneGeometryUpdateTime()
     {
-      return m_CurrentWorldGeometry2DUpdateTime;
+      return m_CurrentWorldPlaneGeometryUpdateTime;
     }
     //##Documentation
     //## @brief Get timestamp of last call of SetDisplayGeometry
     unsigned long GetDisplayGeometryUpdateTime()
     {
-      return m_CurrentWorldGeometry2DUpdateTime;
+      return m_CurrentWorldPlaneGeometryUpdateTime;
     }
     //##Documentation
     //## @brief Get timestamp of last change of current TimeStep
     unsigned long GetTimeStepUpdateTime()
     {
       return m_TimeStepUpdateTime;
     }
 
     //##Documentation
     //## @brief Perform a picking: find the x,y,z world coordinate of a
     //## display x,y coordinate.
     //## @warning Has to be overwritten in subclasses for the 3D-case.
     //##
     //## Implemented here only for 2D-rendering by using
     //## m_DisplayGeometry
     virtual void PickWorldPoint(const Point2D& diplayPosition, Point3D& worldPosition) const;
 
     /** \brief Determines the object (mitk::DataNode) closest to the current
      * position by means of picking
      *
      * \warning Implementation currently empty for 2D rendering; intended to be
      * implemented for 3D renderers */
     virtual DataNode* PickObject(const Point2D& /*displayPosition*/, Point3D& /*worldPosition*/) const
     {
       return NULL;
     }
 
     //##Documentation
     //## @brief Get the MapperSlotId to use.
     itkGetMacro(MapperID, MapperSlotId)
     itkGetConstMacro(MapperID, MapperSlotId)
 
     //##Documentation
     //## @brief Set the MapperSlotId to use.
     itkSetMacro(MapperID, MapperSlotId)
 
     //##Documentation
     //## @brief Has the renderer the focus?
     itkGetMacro(Focused, bool)
     //##Documentation
     //## @brief Tell the renderer that it is focused. The caller is responsible for focus management,
     //## not the renderer itself.
     itkSetMacro(Focused, bool)
 
     itkGetMacro(Size, int*)
 
     void SetSliceNavigationController(SliceNavigationController* SlicenavigationController);
     void SetCameraController(CameraController* cameraController);
     itkGetObjectMacro(CameraController, CameraController)
     itkGetObjectMacro(SliceNavigationController, SliceNavigationController)
     itkGetObjectMacro(CameraRotationController, CameraRotationController)
 
     itkGetMacro(EmptyWorldGeometry, bool)
 
     //##Documentation
     //## @brief Mouse event dispatchers
     //## @note for internal use only. preliminary.
     virtual void MousePressEvent(MouseEvent*);
     //##Documentation
     //## @brief Mouse event dispatchers
     //## @note for internal use only. preliminary.
     virtual void MouseReleaseEvent(MouseEvent*);
     //##Documentation
     //## @brief Mouse event dispatchers
     //## @note for internal use only. preliminary.
     virtual void MouseMoveEvent(MouseEvent*);
     //##Documentation
     //## @brief Wheel event dispatcher
     //## @note for internal use only. preliminary.
     virtual void WheelEvent(mitk::WheelEvent* we);
     //##Documentation
     //## @brief Key event dispatcher
     //## @note for internal use only. preliminary.
     virtual void KeyPressEvent(KeyEvent*);
 
     //##Documentation
     //## @brief get the name of the Renderer
     //## @note
     const char * GetName() const
     {
       return m_Name.c_str();
     }
 
     //##Documentation
     //## @brief get the x_size of the RendererWindow
     //## @note
     int GetSizeX() const
     {
       return m_Size[0];
     }
 
     //##Documentation
     //## @brief get the y_size of the RendererWindow
     //## @note
     int GetSizeY() const
     {
       return m_Size[1];
     }
 
     const double* GetBounds() const;
 
     void RequestUpdate();
     void ForceImmediateUpdate();
 
     /** Returns number of mappers which are visible and have level-of-detail
      * rendering enabled */
     unsigned int GetNumberOfVisibleLODEnabledMappers() const;
 
     ///**
     //* \brief Setter for the RenderingManager that handles this instance of BaseRenderer
     //*/
     //void SetRenderingManager( mitk::RenderingManager* );
 
     /**
      * \brief Getter for the RenderingManager that handles this instance of BaseRenderer
      */
     virtual mitk::RenderingManager* GetRenderingManager() const;
 
     /**
      * \brief Provides (1) world coordinates for a given mouse position and (2)
      * translates mousePosition to Display coordinates
      */
     virtual Point3D Map2DRendererPositionTo3DWorldPosition(const Point2D& mousePosition) const;
 
     /**
     * \deprecatedSince{2014_03} Please use Map2DRendererPositionTo3DWorldPosition(const Point2D& mousePosition) const
     */
     DEPRECATED(Point3D Map2DRendererPositionTo3DWorldPosition(Point2D* mousePosition) const);
 
   protected:
 
     virtual ~BaseRenderer();
 
     //##Documentation
     //## @brief Call update of all mappers. To be implemented in subclasses.
     virtual void Update() = 0;
 
     vtkRenderWindow* m_RenderWindow;
     vtkRenderer* m_VtkRenderer;
 
     //##Documentation
     //## @brief MapperSlotId to use. Defines which kind of mapper (e.g., 2D or 3D) shoud be used.
     MapperSlotId m_MapperID;
 
     //##Documentation
     //## @brief The DataStorage that is used for rendering.
     DataStorage::Pointer m_DataStorage;
 
     //##Documentation
     //## @brief The RenderingManager that manages this instance
     RenderingManager::Pointer m_RenderingManager;
 
     //##Documentation
     //## @brief Timestamp of last call of Update().
     unsigned long m_LastUpdateTime;
 
     //##Documentation
     //## @brief CameraController for 3D rendering
     //## @note preliminary.
     CameraController::Pointer m_CameraController;
     SliceNavigationController::Pointer m_SliceNavigationController;
     CameraRotationController::Pointer m_CameraRotationController;
 
     //##Documentation
     //## @brief Size of the RenderWindow.
     int m_Size[2];
 
     //##Documentation
     //## @brief Contains whether the renderer that it is focused. The caller of
     //## SetFocused is responsible for focus management, not the renderer itself.
     //## is doubled because of mitk::FocusManager in GlobalInteraction!!! (ingmar)
     bool m_Focused;
 
     //##Documentation
-    //## @brief Sets m_CurrentWorldGeometry2D
-    virtual void SetCurrentWorldGeometry2D(PlaneGeometry* geometry2d);
+    //## @brief Sets m_CurrentWorldPlaneGeometry
+    virtual void SetCurrentWorldPlaneGeometry(PlaneGeometry* geometry2d);
 
     //##Documentation
     //## @brief Sets m_CurrentWorldGeometry
     virtual void SetCurrentWorldGeometry(BaseGeometry* geometry);
 
     //##Documentation
     //## @brief This method is called during the rendering process to update or render the Overlays
     //## which are stored in the OverlayManager
     void UpdateOverlays();
 
   private:
     //##Documentation
     //## Pointer to the worldgeometry, describing the maximal area to be rendered
     //## (3D as well as 2D).
     //## It is const, since we are not allowed to change it (it may be taken
     //## directly from the geometry of an image-slice and thus it would be
     //## very strange when suddenly the image-slice changes its geometry).
     //## \sa SetWorldGeometry
     BaseGeometry::Pointer m_WorldGeometry;
 
     itk::SmartPointer<OverlayManager> m_OverlayManager;
 
     //##Documentation
-    //## m_WorldTimeGeometry is set by SetWorldGeometry if the passed Geometry3D is a
+    //## m_WorldTimeGeometry is set by SetWorldGeometry if the passed BaseGeometry is a
     //## TimeGeometry (or a sub-class of it). If it contains instances of SlicedGeometry3D,
     //## m_Slice and m_TimeStep (set via SetSlice and SetTimeStep, respectively) define
     //## which 2D geometry stored in m_WorldTimeGeometry (if available)
-    //## is used as m_CurrentWorldGeometry2D.
-    //## \sa m_CurrentWorldGeometry2D
+    //## is used as m_CurrentWorldPlaneGeometry.
+    //## \sa m_CurrentWorldPlaneGeometry
     TimeGeometry::Pointer m_WorldTimeGeometry;
 
     //##Documentation
     //## Pointer to the current 3D-worldgeometry.
     BaseGeometry::Pointer m_CurrentWorldGeometry;
 
     //##Documentation
     //## Pointer to the current 2D-worldgeometry. The 2D-worldgeometry
     //## describes the maximal area (2D manifold) to be rendered in case we
     //## are doing 2D-rendering. More precisely, a subpart of this according
     //## to m_DisplayGeometry is displayed.
     //## It is const, since we are not allowed to change it (it may be taken
     //## directly from the geometry of an image-slice and thus it would be
     //## very strange when suddenly the image-slice changes its geometry).
-    PlaneGeometry::Pointer m_CurrentWorldGeometry2D;
+    PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
 
     //##Documentation
     //## Pointer to the displaygeometry. The displaygeometry describes the
     //## geometry of the \em visible area in the window controlled by the renderer
     //## in case we are doing 2D-rendering.
     //## It is const, since we are not allowed to change it.
     DisplayGeometry::Pointer m_DisplayGeometry;
 
     //##Documentation
     //## Defines together with m_Slice which 2D geometry stored in m_WorldTimeGeometry
-    //## is used as m_CurrentWorldGeometry2D: m_WorldTimeGeometry->GetGeometry2D(m_Slice, m_TimeStep).
+    //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_Slice;
     //##Documentation
     //## Defines together with m_TimeStep which 2D geometry stored in m_WorldTimeGeometry
-    //## is used as m_CurrentWorldGeometry2D: m_WorldTimeGeometry->GetGeometry2D(m_Slice, m_TimeStep).
+    //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_TimeStep;
 
     //##Documentation
     //## @brief timestamp of last call of SetWorldGeometry
-    itk::TimeStamp m_CurrentWorldGeometry2DUpdateTime;
+    itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
 
     //##Documentation
     //## @brief timestamp of last call of SetDisplayGeometry
     itk::TimeStamp m_DisplayGeometryUpdateTime;
 
     //##Documentation
     //## @brief timestamp of last change of the current time step
     itk::TimeStamp m_TimeStepUpdateTime;
 
     //##Documentation
     //## @brief Helper class which establishes connection between Interactors and Dispatcher via a common DataStorage.
     BindDispatcherInteractor* m_BindDispatcherInteractor;
 
   protected:
     virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
     //##Documentation
     //## Data object containing the m_WorldGeometry defined above.
-    Geometry2DData::Pointer m_WorldGeometryData;
+    PlaneGeometryData::Pointer m_WorldGeometryData;
     //##Documentation
     //## Data object containing the m_DisplayGeometry defined above.
-    Geometry2DData::Pointer m_DisplayGeometryData;
+    PlaneGeometryData::Pointer m_DisplayGeometryData;
     //##Documentation
-    //## Data object containing the m_CurrentWorldGeometry2D defined above.
-    Geometry2DData::Pointer m_CurrentWorldGeometry2DData;
+    //## Data object containing the m_CurrentWorldPlaneGeometry defined above.
+    PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
 
     //##Documentation
     //## DataNode objects containing the m_WorldGeometryData defined above.
     DataNode::Pointer m_WorldGeometryNode;
     //##Documentation
     //## DataNode objects containing the m_DisplayGeometryData defined above.
     DataNode::Pointer m_DisplayGeometryNode;
     //##Documentation
-    //## DataNode objects containing the m_CurrentWorldGeometry2DData defined above.
-    DataNode::Pointer m_CurrentWorldGeometry2DNode;
+    //## DataNode objects containing the m_CurrentWorldPlaneGeometryData defined above.
+    DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
 
     //##Documentation
     //## @brief test only
     unsigned long m_DisplayGeometryTransformTime;
     //##Documentation
     //## @brief test only
-    unsigned long m_CurrentWorldGeometry2DTransformTime;
+    unsigned long m_CurrentWorldPlaneGeometryTransformTime;
 
     std::string m_Name;
 
     double m_Bounds[6];
 
     bool m_EmptyWorldGeometry;
 
     typedef std::set<Mapper *> LODEnabledMappersType;
 
     /** Number of mappers which are visible and have level-of-detail
      * rendering enabled */
     unsigned int m_NumberOfVisibleLODEnabledMappers;
 
     // Local Storage Handling for mappers
 
   protected:
 
     std::list<mitk::BaseLocalStorageHandler*> m_RegisteredLocalStorageHandlers;
 
   public:
 
     void RemoveAllLocalStorages();
     void RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
     void UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
   };
 } // namespace mitk
 
 #endif /* BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4 */
\ No newline at end of file
diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
index e0a8e9a41e..9db61c7bd3 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,1073 +1,1073 @@
 /*===================================================================
 
 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"
 
 //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,
+  //The 3D RW Mapper (PlaneGeometryDataVtkMapper3D) 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 PlaneGeometry *worldGeometry = renderer->GetCurrentWorldGeometry2D();
+  const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   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();
+    DataNode *dn=renderer->GetCurrentWorldPlaneGeometryNode();
     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);
 
   // 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::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::LOOKUPTABLE_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::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;
     default:
       MITK_ERROR << "No valid 'Image Rendering.Mode' set. Using LOOKUPTABLE_LEVELWINDOW_COLOR instead.";
       this->ApplyLookuptable( renderer );
       this->ApplyLevelWindow( renderer );
       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 < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
+       || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->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 ) );
 
   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();
   mitkLut->SetType(mitk::LookupTable::GRAYSCALE);
   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
   }
 
   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);
 
   //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);
   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 PlaneGeometry* 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();
 
   mitkLUT->SetType(mitk::LookupTable::LEGACY_RAINBOW_COLOR);
   m_ColorLookupTable = mitkLUT->GetVtkLookupTable();
 
   //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/mitkGeometry2DDataMapper2D.cpp b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.cpp
similarity index 87%
rename from Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
rename to Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.cpp
index 53b80dd4b0..c1cde19943 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.cpp
@@ -1,671 +1,671 @@
 /*===================================================================
 
 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 "mitkGL.h"
-#include "mitkGeometry2DDataMapper2D.h"
+#include "mitkPlaneGeometryDataMapper2D.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkPlaneOrientationProperty.h"
-#include "mitkGeometry2DDataToSurfaceFilter.h"
+#include "mitkPlaneGeometryDataToSurfaceFilter.h"
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkLine.h"
 #include "mitkNodePredicateDataType.h"
 
 #include "mitkResliceMethodProperty.h"
 
 
-mitk::Geometry2DDataMapper2D::Geometry2DDataMapper2D()
+mitk::PlaneGeometryDataMapper2D::PlaneGeometryDataMapper2D()
 : m_SurfaceMapper( NULL ), m_DataStorage(NULL), m_ParentNode(NULL),
-  m_OtherGeometry2Ds(), m_RenderOrientationArrows( false ),
+  m_OtherPlaneGeometries(), m_RenderOrientationArrows( false ),
   m_ArrowOrientationPositive( true )
 {
 }
 
 
-mitk::Geometry2DDataMapper2D::~Geometry2DDataMapper2D()
+mitk::PlaneGeometryDataMapper2D::~PlaneGeometryDataMapper2D()
 {
 }
 
 
-const mitk::Geometry2DData* mitk::Geometry2DDataMapper2D::GetInput(void)
+const mitk::PlaneGeometryData* mitk::PlaneGeometryDataMapper2D::GetInput(void)
 {
-  return static_cast<const Geometry2DData * > ( GetDataNode()->GetData() );
+  return static_cast<const PlaneGeometryData * > ( GetDataNode()->GetData() );
 }
 
-void mitk::Geometry2DDataMapper2D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
+void mitk::PlaneGeometryDataMapper2D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   if(!ls->IsGenerateDataRequired(renderer,this,GetDataNode()))
     return;
 
   ls->UpdateGenerateDataTime();
 
-  // collect all Geometry2DDatas accessible from the DataStorage
-  m_OtherGeometry2Ds.clear();
+  // collect all PlaneGeometryDatas accessible from the DataStorage
+  m_OtherPlaneGeometries.clear();
   if (m_DataStorage.IsNull())
     return;
 
-  mitk::NodePredicateDataType::Pointer p = mitk::NodePredicateDataType::New("Geometry2DData");
+  mitk::NodePredicateDataType::Pointer p = mitk::NodePredicateDataType::New("PlaneGeometryData");
   mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetDerivations(m_ParentNode, p, false);
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
   {
     if(it->Value().IsNull())
       continue;
 
     BaseData* data = it->Value()->GetData();
     if (data == NULL)
       continue;
 
-    Geometry2DData* geometry2dData = dynamic_cast<Geometry2DData*>(data);
+    PlaneGeometryData* geometry2dData = dynamic_cast<PlaneGeometryData*>(data);
     if(geometry2dData == NULL)
       continue;
 
-    PlaneGeometry* planegeometry = dynamic_cast<PlaneGeometry*>(geometry2dData->GetGeometry2D());
+    PlaneGeometry* planegeometry = dynamic_cast<PlaneGeometry*>(geometry2dData->GetPlaneGeometry());
     if (planegeometry != NULL)
-      m_OtherGeometry2Ds.push_back(it->Value());
+      m_OtherPlaneGeometries.push_back(it->Value());
   }
 }
 
 
-void mitk::Geometry2DDataMapper2D::Paint(BaseRenderer *renderer)
+void mitk::PlaneGeometryDataMapper2D::Paint(BaseRenderer *renderer)
 {
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if(!visible) return;
 
-  Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());
+  PlaneGeometryData::Pointer input = const_cast< PlaneGeometryData * >(this->GetInput());
 
   // intersecting with ourself?
-  if ( input.IsNull() || (this->GetInput()->GetGeometry2D() ==
-       renderer->GetCurrentWorldGeometry2D()) )
+  if ( input.IsNull() || (this->GetInput()->GetPlaneGeometry() ==
+       renderer->GetCurrentWorldPlaneGeometry()) )
   {
     return; // do nothing!
   }
 
   const PlaneGeometry *inputPlaneGeometry =
-    dynamic_cast< const PlaneGeometry * >( input->GetGeometry2D() );
+    dynamic_cast< const PlaneGeometry * >( input->GetPlaneGeometry() );
 
   const PlaneGeometry *worldPlaneGeometry =
     dynamic_cast< const PlaneGeometry* >(
-    renderer->GetCurrentWorldGeometry2D() );
+    renderer->GetCurrentWorldPlaneGeometry() );
 
   if ( worldPlaneGeometry && inputPlaneGeometry
     && inputPlaneGeometry->GetReferenceGeometry() )
   {
     DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
     assert( displayGeometry );
 
     const BaseGeometry *referenceGeometry =
       inputPlaneGeometry->GetReferenceGeometry();
 
     // calculate intersection of the plane data with the border of the
     // world geometry rectangle
     Point2D lineFrom, lineTo;
 
     const Geometry3D::TransformType *transform = dynamic_cast< const Geometry3D::TransformType * >(
       referenceGeometry->GetIndexToWorldTransform() );
 
     Geometry3D::TransformType::Pointer inverseTransform = Geometry3D::TransformType::New();
     transform->GetInverse( inverseTransform );
 
     Line3D crossLine, otherCrossLine;
 
     // Calculate the intersection line of the input plane with the world plane
     if ( worldPlaneGeometry->IntersectionLine(
           inputPlaneGeometry, crossLine ) )
     {
       BoundingBox::PointType boundingBoxMin, boundingBoxMax;
       boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
       boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();
       if(referenceGeometry->GetImageGeometry())
       {
         for(unsigned int i = 0; i < 3; ++i)
         {
           boundingBoxMin[i]-=0.5;
           boundingBoxMax[i]-=0.5;
         }
       }
 
       crossLine.Transform( *inverseTransform );
       Point3D point1, point2;
 
       // Then, clip this line with the (transformed) bounding box of the
       // reference geometry.
       if ( crossLine.BoxLineIntersection(
         boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2],
         boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2],
         crossLine.GetPoint(), crossLine.GetDirection(),
         point1, point2 ) == 2 )
       {
         // Transform the resulting line start and end points into display
         // coordinates.
         worldPlaneGeometry->Map(
           transform->TransformPoint( point1 ), lineFrom );
         worldPlaneGeometry->Map(
           transform->TransformPoint( point2 ), lineTo );
 
         Line< ScalarType, 2 > mainLine, otherLine;
         Line< ScalarType, 2 > primaryHelperLine, secondaryHelperLine;
         mainLine.SetPoints( lineFrom, lineTo );
         primaryHelperLine.SetPoints( lineFrom, lineTo );
         secondaryHelperLine.SetPoints( lineFrom, lineTo );
 
         displayGeometry->WorldToDisplay( lineFrom, lineFrom );
         displayGeometry->WorldToDisplay( lineTo, lineTo );
 
         ScalarType lengthInDisplayUnits = (lineTo - lineFrom).GetNorm();
 
         Vector2D mainLineDirectionOrthogonal;
         mainLineDirectionOrthogonal[0] = -mainLine.GetDirection()[1];
         mainLineDirectionOrthogonal[1] = mainLine.GetDirection()[0];
 
 
         // lineParams stores the individual segments of the line, which are
         // separated by a gap each (to mark the intersection with another
         // displayed line)
         std::vector< ScalarType > mainLineParams;
         std::vector< ScalarType > primaryHelperLineParams;
         std::vector< ScalarType > secondaryHelperLineParams;
-        mainLineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
+        mainLineParams.reserve( m_OtherPlaneGeometries.size() + 2 );
         mainLineParams.push_back( 0.0 );
         mainLineParams.push_back( 1.0 );
 
-        primaryHelperLineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
+        primaryHelperLineParams.reserve( m_OtherPlaneGeometries.size() + 2 );
         primaryHelperLineParams.push_back( 0.0 );
         primaryHelperLineParams.push_back( 1.0 );
 
-        secondaryHelperLineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
+        secondaryHelperLineParams.reserve( m_OtherPlaneGeometries.size() + 2 );
         secondaryHelperLineParams.push_back( 0.0 );
         secondaryHelperLineParams.push_back( 1.0 );
 
 
         // Now iterate through all other lines displayed in this window and
         // calculate the positions of intersection with the line to be
         // rendered; these positions will be stored in lineParams to form a
         // gap afterwards.
-        NodesVectorType::iterator otherPlanesIt = m_OtherGeometry2Ds.begin();
-        NodesVectorType::iterator otherPlanesEnd = m_OtherGeometry2Ds.end();
+        NodesVectorType::iterator otherPlanesIt = m_OtherPlaneGeometries.begin();
+        NodesVectorType::iterator otherPlanesEnd = m_OtherPlaneGeometries.end();
 
         //int mainLineThickSlicesMode = 0;
         int mainLineThickSlicesNum = 1;
 
         DataNode* dataNodeOfInputPlaneGeometry = NULL;
 
         // Now we have to find the DataNode that contains the inputPlaneGeometry
         // in order to determine the state of the thick-slice rendering
         while ( otherPlanesIt != otherPlanesEnd )
         {
           PlaneGeometry *otherPlane = static_cast< PlaneGeometry * >(
-            static_cast< Geometry2DData * >(
-            (*otherPlanesIt)->GetData() )->GetGeometry2D() );
+            static_cast< PlaneGeometryData * >(
+            (*otherPlanesIt)->GetData() )->GetPlaneGeometry() );
 
           // if we have found the correct node
           if ( (otherPlane == inputPlaneGeometry)
             && worldPlaneGeometry->IntersectionLine(
             otherPlane, otherCrossLine ) )
           {
             dataNodeOfInputPlaneGeometry = (*otherPlanesIt);
 //            if( dataNodeOfInputPlaneGeometry )
 //            {
 //              mainLineThickSlicesMode = this->DetermineThickSliceMode(dataNodeOfInputPlaneGeometry, mainLineThickSlicesNum);
 //            }
             break;
           }
           otherPlanesIt++;
         }
 
         // if we did not find a dataNode for the inputPlaneGeometry there is nothing we can do from here
         if ( dataNodeOfInputPlaneGeometry == NULL )
           return;
 
         // Determine if we should draw the area covered by the thick slicing, default is false.
         // This will also show the area of slices that do not have thick slice mode enabled
         bool showAreaOfThickSlicing = false;
         dataNodeOfInputPlaneGeometry->GetBoolProperty( "reslice.thickslices.showarea", showAreaOfThickSlicing );
 
         // get the normal of the inputPlaneGeometry
         Vector3D normal = inputPlaneGeometry->GetNormal();
         // determine the pixelSpacing in that direction
         double thickSliceDistance = SlicedGeometry3D::CalculateSpacing( referenceGeometry->GetSpacing(), normal );
 
         // As the inputPlaneGeometry cuts through the center of the slice in the middle
         // we have to add 0.5 pixel in order to compensate.
         thickSliceDistance *= mainLineThickSlicesNum+0.5;
 
         // not the nicest place to do it, but we have the width of the visible bloc in MM here
         // so we store it in this fancy property
         dataNodeOfInputPlaneGeometry->SetFloatProperty( "reslice.thickslices.sizeinmm", thickSliceDistance*2 );
 
         if ( showAreaOfThickSlicing )
         {
           // vectorToHelperLine defines how to reach the helperLine from the mainLine
           Vector2D vectorToHelperLine;
           vectorToHelperLine = mainLineDirectionOrthogonal;
           vectorToHelperLine.Normalize();
           // got the right direction, so we multiply the width
           vectorToHelperLine *= thickSliceDistance;
 
           // and create the corresponding points
           primaryHelperLine.SetPoints( primaryHelperLine.GetPoint1() - vectorToHelperLine,
             primaryHelperLine.GetPoint2() - vectorToHelperLine );
 
           secondaryHelperLine.SetPoints( secondaryHelperLine.GetPoint1() + vectorToHelperLine,
             secondaryHelperLine.GetPoint2() + vectorToHelperLine );
         }
 
 
         //int otherLineThickSlicesMode = 0;
         int otherLineThickSlicesNum = 1;
 
         // by default, there is no gap for the helper lines
         ScalarType gapSize = 0.0;
 
-        otherPlanesIt = m_OtherGeometry2Ds.begin();
+        otherPlanesIt = m_OtherPlaneGeometries.begin();
         while ( otherPlanesIt != otherPlanesEnd )
         {
           PlaneGeometry *otherPlane = static_cast< PlaneGeometry * >(
-            static_cast< Geometry2DData * >(
-              (*otherPlanesIt)->GetData() )->GetGeometry2D() );
+            static_cast< PlaneGeometryData * >(
+              (*otherPlanesIt)->GetData() )->GetPlaneGeometry() );
 
 
           // Just as with the original line, calculate the intersection with
           // the world geometry...
           if ( (otherPlane != inputPlaneGeometry)
             && worldPlaneGeometry->IntersectionLine(
                  otherPlane, otherCrossLine ) )
           {
             //otherLineThickSlicesMode = this->DetermineThickSliceMode((*otherPlanesIt), otherLineThickSlicesNum);
             Vector3D normal = otherPlane->GetNormal();
 
             double otherLineThickSliceDistance = SlicedGeometry3D::CalculateSpacing( referenceGeometry->GetSpacing(), normal );
             otherLineThickSliceDistance *= (otherLineThickSlicesNum+0.5)*2;
 
             Point2D otherLineFrom, otherLineTo;
 
             // ... and clip the resulting line segment with the reference
             // geometry bounding box.
             otherCrossLine.Transform( *inverseTransform );
             if ( otherCrossLine.BoxLineIntersection(
               boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2],
               boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2],
               otherCrossLine.GetPoint(), otherCrossLine.GetDirection(),
               point1, point2 ) == 2 )
             {
               worldPlaneGeometry->Map(
                 transform->TransformPoint( point1 ), otherLineFrom );
               worldPlaneGeometry->Map(
                 transform->TransformPoint( point2 ), otherLineTo );
 
               otherLine.SetPoints( otherLineFrom, otherLineTo );
 
               // then we have to determine the gap position of the main line
               // by finding the position at which the two lines cross
               this->DetermineParametricCrossPositions( mainLine, otherLine, mainLineParams );
 
 
               // if the other line is also in thick slice mode, we have to determine the
               // gapsize considering the width of that other line and the spacing in its direction
               if ( showAreaOfThickSlicing )
               {
                 Vector2D otherLineDirection = otherLine.GetDirection();
                 otherLineDirection.Normalize();
                 mainLineDirectionOrthogonal.Normalize();
 
                 // determine the gapsize
                 gapSize = fabs( otherLineThickSliceDistance / ( otherLineDirection*mainLineDirectionOrthogonal ) );
                 gapSize = gapSize / displayGeometry->GetScaleFactorMMPerDisplayUnit();
 
                 // determine the gap positions for the helper lines as well
                 this->DetermineParametricCrossPositions( primaryHelperLine, otherLine, primaryHelperLineParams );
                 this->DetermineParametricCrossPositions( secondaryHelperLine, otherLine, secondaryHelperLineParams );
               }
             }
           }
           ++otherPlanesIt;
         }
 
         // If we have to draw the helperlines, the mainline will be drawn as a dashed line
         // with a fixed gapsize of 10 pixels
         this->DrawLine(renderer,
           lengthInDisplayUnits,
           mainLine,
           mainLineParams,
           inputPlaneGeometry,
           showAreaOfThickSlicing,
           10.0
           );
 
 
         // If drawn, the helperlines are drawn as a solid line. The gapsize depends on the
         // width of the crossed line.
         if ( showAreaOfThickSlicing )
         {
           this->DrawLine(renderer,
             lengthInDisplayUnits,
             primaryHelperLine,
             primaryHelperLineParams,
             inputPlaneGeometry,
             false,
             gapSize
             );
 
           this->DrawLine(renderer,
             lengthInDisplayUnits,
             secondaryHelperLine,
             secondaryHelperLineParams,
             inputPlaneGeometry,
             false,
             gapSize
             );
         }
       }
     }
   }
   else
   {
-    Geometry2DDataToSurfaceFilter::Pointer surfaceCreator;
+    PlaneGeometryDataToSurfaceFilter::Pointer surfaceCreator;
     SmartPointerProperty::Pointer surfacecreatorprop;
     surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(
       GetDataNode()->GetProperty(
         "surfacegeometry", renderer));
 
     if( (surfacecreatorprop.IsNull()) ||
         (surfacecreatorprop->GetSmartPointer().IsNull()) ||
-        ((surfaceCreator = dynamic_cast< Geometry2DDataToSurfaceFilter * >(
+        ((surfaceCreator = dynamic_cast< PlaneGeometryDataToSurfaceFilter * >(
           surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull())
       )
     {
-      surfaceCreator = Geometry2DDataToSurfaceFilter::New();
+      surfaceCreator = PlaneGeometryDataToSurfaceFilter::New();
       surfacecreatorprop = SmartPointerProperty::New(surfaceCreator);
       surfaceCreator->PlaceByGeometryOn();
       GetDataNode()->SetProperty( "surfacegeometry", surfacecreatorprop );
     }
 
     surfaceCreator->SetInput( input );
 
     // Clip the PlaneGeometry with the reference geometry bounds (if available)
-    if ( input->GetGeometry2D()->HasReferenceGeometry() )
+    if ( input->GetPlaneGeometry()->HasReferenceGeometry() )
     {
       surfaceCreator->SetBoundingBox(
-        input->GetGeometry2D()->GetReferenceGeometry()->GetBoundingBox()
+        input->GetPlaneGeometry()->GetReferenceGeometry()->GetBoundingBox()
       );
     }
 
     int res;
     bool usegeometryparametricbounds = true;
     if ( GetDataNode()->GetIntProperty("xresolution", res, renderer))
     {
       surfaceCreator->SetXResolution(res);
       usegeometryparametricbounds=false;
     }
     if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
     {
       surfaceCreator->SetYResolution(res);
       usegeometryparametricbounds=false;
     }
     surfaceCreator->SetUseGeometryParametricBounds(usegeometryparametricbounds);
 
     // Calculate the surface of the PlaneGeometry
     surfaceCreator->Update();
 
     if (m_SurfaceMapper.IsNull())
     {
       m_SurfaceMapper=SurfaceGLMapper2D::New();
     }
     m_SurfaceMapper->SetSurface(surfaceCreator->GetOutput());
     m_SurfaceMapper->SetDataNode(GetDataNode());
 
     m_SurfaceMapper->Paint(renderer);
   }
 }
 
-void mitk::Geometry2DDataMapper2D::DrawOrientationArrow( mitk::Point2D &outerPoint, mitk::Point2D &innerPoint,
+void mitk::PlaneGeometryDataMapper2D::DrawOrientationArrow( mitk::Point2D &outerPoint, mitk::Point2D &innerPoint,
   const mitk::PlaneGeometry *planeGeometry,
   const mitk::PlaneGeometry *rendererPlaneGeometry,
   const mitk::DisplayGeometry *displayGeometry,
   bool positiveOrientation )
 {
   // Draw arrows to indicate plane orientation
   // Vector along line
   Vector2D v1 = innerPoint - outerPoint;
   v1.Normalize();
   v1 *= 7.0;
 
   // Orthogonal vector
   Vector2D v2;
   v2[0] = v1[1];
   v2[1] = -v1[0];
 
   // Calculate triangle tip for one side and project it back into world
   // coordinates to determine whether it is above or below the plane
   Point2D worldPoint2D;
   Point3D worldPoint;
   displayGeometry->DisplayToWorld( outerPoint + v1 + v2, worldPoint2D );
   rendererPlaneGeometry->Map( worldPoint2D, worldPoint );
 
   // Initialize remaining triangle coordinates accordingly
   // (above/below state is XOR'ed with orientation flag)
   Point2D p1 = outerPoint + v1 * 2.0;
   Point2D p2 = outerPoint + v1
     + ((positiveOrientation ^ planeGeometry->IsAbove( worldPoint ))
     ? v2 : -v2);
 
   // Draw the arrow (triangle)
   glBegin( GL_TRIANGLES );
   glVertex2f( outerPoint[0], outerPoint[1] );
   glVertex2f( p1[0], p1[1] );
   glVertex2f( p2[0], p2[1] );
   glEnd();
 }
 
 
-void mitk::Geometry2DDataMapper2D::ApplyAllProperties( BaseRenderer *renderer )
+void mitk::PlaneGeometryDataMapper2D::ApplyAllProperties( BaseRenderer *renderer )
 {
   Superclass::ApplyColorAndOpacityProperties(renderer);
 
   PlaneOrientationProperty* decorationProperty;
   this->GetDataNode()->GetProperty( decorationProperty, "decoration", renderer );
   if ( decorationProperty != NULL )
   {
     if ( decorationProperty->GetPlaneDecoration() ==
       PlaneOrientationProperty::PLANE_DECORATION_POSITIVE_ORIENTATION )
     {
       m_RenderOrientationArrows = true;
       m_ArrowOrientationPositive = true;
     }
     else if ( decorationProperty->GetPlaneDecoration() ==
       PlaneOrientationProperty::PLANE_DECORATION_NEGATIVE_ORIENTATION )
     {
       m_RenderOrientationArrows = true;
       m_ArrowOrientationPositive = false;
     }
     else
     {
       m_RenderOrientationArrows = false;
     }
   }
 }
 
 
-void mitk::Geometry2DDataMapper2D::SetDatastorageAndGeometryBaseNode( mitk::DataStorage::Pointer ds, mitk::DataNode::Pointer parent )
+void mitk::PlaneGeometryDataMapper2D::SetDatastorageAndGeometryBaseNode( mitk::DataStorage::Pointer ds, mitk::DataNode::Pointer parent )
 {
   if (ds.IsNotNull())
   {
     m_DataStorage = ds;
   }
   if (parent.IsNotNull())
   {
     m_ParentNode = parent;
   }
 }
 
-void mitk::Geometry2DDataMapper2D::DrawLine( BaseRenderer* renderer,
+void mitk::PlaneGeometryDataMapper2D::DrawLine( BaseRenderer* renderer,
                                             ScalarType lengthInDisplayUnits,
                                             Line<ScalarType,2> &line,
                                             std::vector<ScalarType> &gapPositions,
                                             const PlaneGeometry* inputPlaneGeometry,
                                             bool drawDashed,
                                             ScalarType gapSizeInPixel
                                             )
 {
   DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
   const PlaneGeometry *worldPlaneGeometry =
-    dynamic_cast< const PlaneGeometry* >( renderer->GetCurrentWorldGeometry2D() );
+    dynamic_cast< const PlaneGeometry* >( renderer->GetCurrentWorldPlaneGeometry() );
 
   // Apply color and opacity read from the PropertyList.
   this->ApplyAllProperties( renderer );
 
   ScalarType gapSizeInParamUnits =
     1.0 / lengthInDisplayUnits * gapSizeInPixel;
 
   std::sort( gapPositions.begin(), gapPositions.end() );
 
   Point2D p1, p2;
   ScalarType p1Param, p2Param;
 
   p1Param = gapPositions[0];
   p1 = line.GetPoint( p1Param );
   displayGeometry->WorldToDisplay( p1, p1 );
 
   //Workaround to show the crosshair always on top of a 2D render window
   //The image is usually located at depth = 0 or negative depth values, and thus,
   //the crosshair with depth = 1 is always on top.
   float depthPosition = 1.0f;
 
   if ( drawDashed )
   {
     glEnable(GL_LINE_STIPPLE);
     glLineStipple(1, 0xF0F0);
   }
   glEnable(GL_DEPTH_TEST);
 
   // Iterate over all line segments and display each, with a gap
   // in between.
   unsigned int i, preLastLineParam = gapPositions.size() - 1;
   for ( i = 1; i < preLastLineParam; ++i )
   {
     p2Param = gapPositions[i] - gapSizeInParamUnits * 0.5;
     p2 = line.GetPoint( p2Param );
 
     if ( p2Param > p1Param )
     {
       // Convert intersection points (until now mm) to display
       // coordinates (units).
       displayGeometry->WorldToDisplay( p2, p2 );
 
       // draw
       glBegin (GL_LINES);
       glVertex3f(p1[0],p1[1], depthPosition);
       glVertex3f(p2[0],p2[1], depthPosition);
       glEnd ();
 
       if ( (i == 1) && (m_RenderOrientationArrows) )
       {
         // Draw orientation arrow for first line segment
         this->DrawOrientationArrow( p1, p2,
           inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
           m_ArrowOrientationPositive );
       }
     }
 
     p1Param = p2Param + gapSizeInParamUnits;
     p1 = line.GetPoint( p1Param );
     displayGeometry->WorldToDisplay( p1, p1 );
   }
 
   // Draw last line segment
   p2Param = gapPositions[i];
   p2 = line.GetPoint( p2Param );
   displayGeometry->WorldToDisplay( p2, p2 );
   glBegin( GL_LINES );
   glVertex3f( p1[0], p1[1], depthPosition);
   glVertex3f( p2[0], p2[1], depthPosition);
   glEnd();
 
   if ( drawDashed )
   {
     glDisable(GL_LINE_STIPPLE);
   }
 
   // Draw orientation arrows
   if ( m_RenderOrientationArrows )
   {
     this->DrawOrientationArrow( p2, p1,
       inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
       m_ArrowOrientationPositive );
     if ( preLastLineParam < 2 )
     {
       // If we only have one line segment, draw other arrow, too
       this->DrawOrientationArrow( p1, p2,
         inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
         m_ArrowOrientationPositive );
     }
   }
 
 }
 
-int mitk::Geometry2DDataMapper2D::DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum )
+int mitk::PlaneGeometryDataMapper2D::DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum )
 {
   int thickSlicesMode = 0;
   // determine the state and the extend of the thick-slice mode
   mitk::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=0;
     if(thickSlicesNum > 10) thickSlicesNum=10;
   }
 
   if ( thickSlicesMode == 0 )
     thickSlicesNum = 0;
 
   return thickSlicesMode;
 }
 
-void mitk::Geometry2DDataMapper2D::DetermineParametricCrossPositions( Line< mitk::ScalarType, 2 > &mainLine,
+void mitk::PlaneGeometryDataMapper2D::DetermineParametricCrossPositions( Line< mitk::ScalarType, 2 > &mainLine,
                                                                      Line< mitk::ScalarType, 2 > &otherLine,
                                                                      std::vector< mitk::ScalarType > &crossPositions )
 {
   Vector2D direction, dOrth;
   // By means of the dot product, calculate the gap position as
   // parametric value in the range [0, 1]
   direction = otherLine.GetDirection();
   dOrth[0] = -direction[1]; dOrth[1] = direction[0];
 
 
   ScalarType gapPosition = ( otherLine.GetPoint1() - mainLine.GetPoint1() ) * dOrth;
   ScalarType norm = mainLine.GetDirection() * dOrth;
 
   if ( fabs( norm ) > eps )
   {
     gapPosition /= norm;
     if ( (gapPosition > 0.0) && (gapPosition < 1.0) )
     {
       crossPositions.push_back(gapPosition);
     }
   }
 }
diff --git a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.h b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.h
similarity index 90%
rename from Core/Code/Rendering/mitkGeometry2DDataMapper2D.h
rename to Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.h
index 421c1c05dd..7d6966e43e 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.h
+++ b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.h
@@ -1,123 +1,123 @@
 /*===================================================================
 
 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 MITKGEOMETRY2DDATAMAPPER2D_H_HEADER_INCLUDED_C19C0BFB
 #define MITKGEOMETRY2DDATAMAPPER2D_H_HEADER_INCLUDED_C19C0BFB
 
 #include <MitkCoreExports.h>
 #include "mitkGLMapper.h"
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkDataStorage.h"
 #include "mitkDataNode.h"
 #include "mitkWeakPointer.h"
 
 namespace mitk {
 
 class BaseRenderer;
 
 /**
  * \brief OpenGL-based mapper to display a PlaneGeometry in a 2D window
  *
  * Currently implemented for mapping on PlaneGeometry.
  * The result is normally a line. An important usage of this class is to show
  * the orientation of the slices displayed in other 2D windows.
  *
  *
- * Properties that can be set and influence the Geometry2DDataMapper2D are:
+ * Properties that can be set and influence the PlaneGeometryDataMapper2D are:
  *
  *   - \b "PlaneOrientationProperty": (PlaneOrientationProperty)
 
 
  * \todo implement for AbstractTransformGeometry.
  * \ingroup Mapper
  */
-class MITK_CORE_EXPORT Geometry2DDataMapper2D : public GLMapper
+class MITK_CORE_EXPORT PlaneGeometryDataMapper2D : public GLMapper
 {
 
 public:
-  mitkClassMacro(Geometry2DDataMapper2D, GLMapper);
+  mitkClassMacro(PlaneGeometryDataMapper2D, GLMapper);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /**
-    * \brief Get the Geometry2DData to map
+    * \brief Get the PlaneGeometryData to map
     */
-  const Geometry2DData *GetInput();
+  const PlaneGeometryData *GetInput();
 
   virtual void Paint( BaseRenderer *renderer );
 
   virtual void SetDatastorageAndGeometryBaseNode(mitk::DataStorage::Pointer ds, mitk::DataNode::Pointer parent);
 
   /** Applies properties specific to this mapper */
   virtual void ApplyAllProperties( BaseRenderer *renderer );
 
   LocalStorageHandler<BaseLocalStorage> m_LSH;
 
 protected:
-  Geometry2DDataMapper2D();
+  PlaneGeometryDataMapper2D();
 
-  virtual ~Geometry2DDataMapper2D();
+  virtual ~PlaneGeometryDataMapper2D();
 
   virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
   /**
   * \brief Returns the thick slice mode for the given datanode.
   *
   * This method returns the value of the 'reslice.thickslices' property for
   * the given datanode.
   *   '0': thick slice mode disabled
   *   '1': thick slice mode enabled
   *
   * The variable 'thickSlicesNum' contains the value of the 'reslice.thickslices.num'
   * property that defines how many slices are shown at once.
   */
   int DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum );
 
   /**
   * \brief Determines the cross position of two lines and stores them as parametric coordinates
   *
   * This method determines the parametric position at which a line 'otherLine' crosses another line
   * 'mainLine'. The result is stored in 'crossPositions'.
   */
   void DetermineParametricCrossPositions( Line<ScalarType,2> &mainLine, Line<ScalarType,2> &otherLine, std::vector<ScalarType> &crossPositions );
 
   void DrawLine( BaseRenderer * renderer, ScalarType lengthInDisplayUnits,
                  Line< ScalarType, 2 > &line, std::vector< ScalarType > &gapPositions,
                  const PlaneGeometry * inputPlaneGeometry, bool drawDashed,
                  ScalarType gapSizeInPixel
                  );
 
 
   void DrawOrientationArrow( Point2D &outerPoint, Point2D &innerPoint,
                             const PlaneGeometry *planeGeometry,
                             const PlaneGeometry *rendererPlaneGeometry,
                             const DisplayGeometry *displayGeometry,
                             bool positiveOrientation = true );
 
   SurfaceGLMapper2D::Pointer m_SurfaceMapper;
 
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;  ///< DataStorage that will be searched for sub nodes
   DataNode::Pointer m_ParentNode;  ///< parent node that will be used to search for sub nodes
 
   typedef std::vector<DataNode*> NodesVectorType;
-  NodesVectorType m_OtherGeometry2Ds;
+  NodesVectorType m_OtherPlaneGeometries;
 
   bool m_RenderOrientationArrows;
   bool m_ArrowOrientationPositive;
 };
 } // namespace mitk
 #endif /* MITKGEOMETRY2DDATAMAPPER2D_H_HEADER_INCLUDED_C19C0BFB */
diff --git a/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.cpp b/Core/Code/Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
similarity index 92%
rename from Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.cpp
rename to Core/Code/Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
index 9bed9b4e9f..ac402e7b3e 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
@@ -1,587 +1,587 @@
 /*===================================================================
 
 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 "mitkGeometry2DDataVtkMapper3D.h"
+#include "mitkPlaneGeometryDataVtkMapper3D.h"
 
 #include "mitkImageVtkMapper2D.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkSurface.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkWeakPointerProperty.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 #include "vtkNeverTranslucentTexture.h"
 #include "vtkMitkLevelWindowFilter.h"
 
 #include <vtkAssembly.h>
 #include <vtkDataSetMapper.h>
 #include <vtkFeatureEdges.h>
 #include <vtkHedgeHog.h>
 #include <vtkImageData.h>
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProp3DCollection.h>
 #include <vtkProperty.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTubeFilter.h>
 
 namespace mitk
 {
 
-  Geometry2DDataVtkMapper3D::Geometry2DDataVtkMapper3D()
+  PlaneGeometryDataVtkMapper3D::PlaneGeometryDataVtkMapper3D()
     : m_NormalsActorAdded(false),
     m_DataStorage(NULL)
   {
     m_EdgeTuber = vtkTubeFilter::New();
     m_EdgeMapper = vtkPolyDataMapper::New();
 
-    m_SurfaceCreator = Geometry2DDataToSurfaceFilter::New();
+    m_SurfaceCreator = PlaneGeometryDataToSurfaceFilter::New();
     m_SurfaceCreatorBoundingBox = BoundingBox::New();
     m_SurfaceCreatorPointsContainer = BoundingBox::PointsContainer::New();
     m_Edges = vtkFeatureEdges::New();
 
     m_Edges->BoundaryEdgesOn();
     m_Edges->FeatureEdgesOff();
     m_Edges->NonManifoldEdgesOff();
     m_Edges->ManifoldEdgesOff();
 
     m_EdgeTransformer = vtkTransformPolyDataFilter::New();
     m_NormalsTransformer = vtkTransformPolyDataFilter::New();
     m_EdgeActor = vtkActor::New();
     m_BackgroundMapper = vtkPolyDataMapper::New();
     m_BackgroundActor = vtkActor::New();
     m_Prop3DAssembly = vtkAssembly::New();
     m_ImageAssembly = vtkAssembly::New();
 
     m_SurfaceCreatorBoundingBox->SetPoints( m_SurfaceCreatorPointsContainer );
 
     m_Cleaner = vtkCleanPolyData::New();
 
     m_Cleaner->PieceInvariantOn();
     m_Cleaner->ConvertLinesToPointsOn();
     m_Cleaner->ConvertPolysToLinesOn();
     m_Cleaner->ConvertStripsToPolysOn();
     m_Cleaner->PointMergingOn();
 
     // Make sure that the FeatureEdge algorithm is initialized with a "valid"
     // (though empty) input
     vtkPolyData *emptyPolyData = vtkPolyData::New();
     m_Cleaner->SetInputData( emptyPolyData );
     emptyPolyData->Delete();
 
     m_Edges->SetInputConnection(m_Cleaner->GetOutputPort());
     m_EdgeTransformer->SetInputConnection( m_Edges->GetOutputPort() );
 
     m_EdgeTuber->SetInputConnection( m_EdgeTransformer->GetOutputPort() );
     m_EdgeTuber->SetVaryRadiusToVaryRadiusOff();
     m_EdgeTuber->SetNumberOfSides( 12 );
     m_EdgeTuber->CappingOn();
 
     m_EdgeMapper->SetInputConnection( m_EdgeTuber->GetOutputPort() );
     m_EdgeMapper->ScalarVisibilityOff();
 
     m_BackgroundMapper->SetInputData(emptyPolyData);
     m_BackgroundMapper->Update();
 
     m_EdgeActor->SetMapper( m_EdgeMapper );
 
     m_BackgroundActor->GetProperty()->SetAmbient( 0.5 );
     m_BackgroundActor->GetProperty()->SetColor( 0.0, 0.0, 0.0 );
     m_BackgroundActor->GetProperty()->SetOpacity( 0.0 );
     m_BackgroundActor->SetMapper( m_BackgroundMapper );
 
     vtkProperty * backfaceProperty = m_BackgroundActor->MakeProperty();
     backfaceProperty->SetColor( 0.0, 0.0, 0.0 );
     m_BackgroundActor->SetBackfaceProperty( backfaceProperty );
     backfaceProperty->Delete();
 
     m_FrontHedgeHog = vtkHedgeHog::New();
     m_BackHedgeHog  = vtkHedgeHog::New();
 
     m_FrontNormalsMapper = vtkPolyDataMapper::New();
     m_FrontNormalsMapper->SetInputConnection( m_FrontHedgeHog->GetOutputPort());
     m_BackNormalsMapper = vtkPolyDataMapper::New();
 
     m_Prop3DAssembly->AddPart( m_EdgeActor );
     m_Prop3DAssembly->AddPart( m_ImageAssembly );
     m_FrontNormalsActor = vtkActor::New();
     m_FrontNormalsActor->SetMapper(m_FrontNormalsMapper);
     m_BackNormalsActor = vtkActor::New();
     m_BackNormalsActor->SetMapper(m_BackNormalsMapper);
 
     m_ImageMapperDeletedCommand = MemberCommandType::New();
     m_ImageMapperDeletedCommand->SetCallbackFunction(
-        this, &Geometry2DDataVtkMapper3D::ImageMapperDeletedCallback );
+        this, &PlaneGeometryDataVtkMapper3D::ImageMapperDeletedCallback );
   }
 
-  Geometry2DDataVtkMapper3D::~Geometry2DDataVtkMapper3D()
+  PlaneGeometryDataVtkMapper3D::~PlaneGeometryDataVtkMapper3D()
   {
     m_ImageAssembly->Delete();
     m_Prop3DAssembly->Delete();
     m_EdgeTuber->Delete();
     m_EdgeMapper->Delete();
     m_EdgeTransformer->Delete();
     m_Cleaner->Delete();
     m_Edges->Delete();
     m_NormalsTransformer->Delete();
     m_EdgeActor->Delete();
     m_BackgroundMapper->Delete();
     m_BackgroundActor->Delete();
     m_FrontNormalsMapper->Delete();
     m_FrontNormalsActor->Delete();
     m_FrontHedgeHog->Delete();
     m_BackNormalsMapper->Delete();
     m_BackNormalsActor->Delete();
     m_BackHedgeHog->Delete();
 
     // Delete entries in m_ImageActors list one by one
     m_ImageActors.clear();
 
     m_DataStorage = NULL;
   }
 
-  vtkProp* Geometry2DDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
+  vtkProp* PlaneGeometryDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
   {
     if ( (this->GetDataNode() != NULL )
       && (m_ImageAssembly != NULL) )
       {
       // Do not transform the entire Prop3D assembly, but only the image part
       // here. The colored frame is transformed elsewhere (via m_EdgeTransformer),
       // since only vertices should be transformed there, not the poly data
       // itself, to avoid distortion for anisotropic datasets.
       m_ImageAssembly->SetUserTransform( this->GetDataNode()->GetVtkTransform() );
     }
     return m_Prop3DAssembly;
   }
 
-  void Geometry2DDataVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
+  void PlaneGeometryDataVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
   {
     m_ImageAssembly->SetUserTransform(
         this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
   }
 
-  const Geometry2DData* Geometry2DDataVtkMapper3D::GetInput()
+  const PlaneGeometryData* PlaneGeometryDataVtkMapper3D::GetInput()
   {
-    return static_cast<const Geometry2DData * > ( GetDataNode()->GetData() );
+    return static_cast<const PlaneGeometryData * > ( GetDataNode()->GetData() );
   }
 
-  void Geometry2DDataVtkMapper3D::SetDataStorageForTexture(mitk::DataStorage* storage)
+  void PlaneGeometryDataVtkMapper3D::SetDataStorageForTexture(mitk::DataStorage* storage)
   {
     if(storage != NULL && m_DataStorage != storage )
     {
       m_DataStorage = storage;
       this->Modified();
     }
   }
 
-  void Geometry2DDataVtkMapper3D::ImageMapperDeletedCallback(
+  void PlaneGeometryDataVtkMapper3D::ImageMapperDeletedCallback(
       itk::Object *caller, const itk::EventObject& /*event*/ )
   {
     ImageVtkMapper2D *imageMapper = dynamic_cast< ImageVtkMapper2D * >( caller );
     if ( (imageMapper != NULL) )
     {
       if ( m_ImageActors.count( imageMapper ) > 0)
       {
         m_ImageActors[imageMapper].m_Sender = NULL; // sender is already destroying itself
         m_ImageActors.erase( imageMapper );
       }
     }
   }
 
-  void Geometry2DDataVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
+  void PlaneGeometryDataVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
   {
     SetVtkMapperImmediateModeRendering(m_EdgeMapper);
     SetVtkMapperImmediateModeRendering(m_BackgroundMapper);
 
     // Remove all actors from the assembly, and re-initialize it with the
     // edge actor
     m_ImageAssembly->GetParts()->RemoveAllItems();
 
     bool visible = true;
     GetDataNode()->GetVisibility(visible, renderer, "visible");
 
     if ( !visible )
     {
       // visibility has explicitly to be set in the single actors
       // due to problems when using cell picking:
       // even if the assembly is invisible, the renderer contains
       // references to the assemblies parts. During picking the
       // visibility of each part is checked, and not only for the
       // whole assembly.
       m_ImageAssembly->VisibilityOff();
       m_EdgeActor->VisibilityOff();
       return;
     }
 
     // visibility has explicitly to be set in the single actors
     // due to problems when using cell picking:
     // even if the assembly is invisible, the renderer contains
     // references to the assemblies parts. During picking the
     // visibility of each part is checked, and not only for the
     // whole assembly.
     m_ImageAssembly->VisibilityOn();
     bool drawEdges = true;
     this->GetDataNode()->GetBoolProperty("draw edges", drawEdges, renderer);
     m_EdgeActor->SetVisibility(drawEdges);
 
-    Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());
+    PlaneGeometryData::Pointer input = const_cast< PlaneGeometryData * >(this->GetInput());
 
-    if (input.IsNotNull() && (input->GetGeometry2D() != NULL))
+    if (input.IsNotNull() && (input->GetPlaneGeometry() != NULL))
     {
       SmartPointerProperty::Pointer surfacecreatorprop;
       surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(GetDataNode()->GetProperty("surfacegeometry", renderer));
 
       if ( (surfacecreatorprop.IsNull())
         || (surfacecreatorprop->GetSmartPointer().IsNull())
-        || ((m_SurfaceCreator = dynamic_cast<Geometry2DDataToSurfaceFilter*>
+        || ((m_SurfaceCreator = dynamic_cast<PlaneGeometryDataToSurfaceFilter*>
              (surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull() ) )
         {
         m_SurfaceCreator->PlaceByGeometryOn();
         surfacecreatorprop = SmartPointerProperty::New( m_SurfaceCreator );
         GetDataNode()->SetProperty("surfacegeometry", surfacecreatorprop);
       }
 
       m_SurfaceCreator->SetInput(input);
 
       int res;
       if (GetDataNode()->GetIntProperty("xresolution", res, renderer))
       {
         m_SurfaceCreator->SetXResolution(res);
       }
       if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
       {
         m_SurfaceCreator->SetYResolution(res);
       }
 
       double tubeRadius = 1.0; // Radius of tubular edge surrounding plane
 
       // Clip the PlaneGeometry with the reference geometry bounds (if available)
-      if ( input->GetGeometry2D()->HasReferenceGeometry() )
+      if ( input->GetPlaneGeometry()->HasReferenceGeometry() )
       {
         BaseGeometry *referenceGeometry =
-            input->GetGeometry2D()->GetReferenceGeometry();
+            input->GetPlaneGeometry()->GetReferenceGeometry();
 
         BoundingBox::PointType boundingBoxMin, boundingBoxMax;
         boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
         boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();
 
         if ( referenceGeometry->GetImageGeometry() )
         {
           for ( unsigned int i = 0; i < 3; ++i )
           {
             boundingBoxMin[i] -= 0.5;
             boundingBoxMax[i] -= 0.5;
           }
         }
 
         m_SurfaceCreatorPointsContainer->CreateElementAt( 0 ) = boundingBoxMin;
         m_SurfaceCreatorPointsContainer->CreateElementAt( 1 ) = boundingBoxMax;
 
         m_SurfaceCreatorBoundingBox->ComputeBoundingBox();
 
         m_SurfaceCreator->SetBoundingBox( m_SurfaceCreatorBoundingBox );
 
         tubeRadius = referenceGeometry->GetDiagonalLength() / 450.0;
       }
 
       // If no reference geometry is available, clip with the current global
       // bounds
       else if (m_DataStorage.IsNotNull())
       {
         m_SurfaceCreator->SetBoundingBox(m_DataStorage->ComputeVisibleBoundingBox(NULL, "includeInBoundingBox"));
         tubeRadius = sqrt( m_SurfaceCreator->GetBoundingBox()->GetDiagonalLength2() ) / 450.0;
       }
 
       // Calculate the surface of the PlaneGeometry
       m_SurfaceCreator->Update();
       Surface *surface = m_SurfaceCreator->GetOutput();
 
       // Check if there's something to display, otherwise return
       if ( (surface->GetVtkPolyData() == 0 )
         || (surface->GetVtkPolyData()->GetNumberOfCells() == 0) )
         {
         m_ImageAssembly->VisibilityOff();
         return;
       }
 
       // add a graphical representation of the surface normals if requested
       DataNode* node = this->GetDataNode();
       bool displayNormals = false;
       bool colorTwoSides = false;
       bool invertNormals = false;
       node->GetBoolProperty("draw normals 3D", displayNormals, renderer);
       node->GetBoolProperty("color two sides", colorTwoSides, renderer);
       node->GetBoolProperty("invert normals", invertNormals, renderer);
 
       //if we want to draw the display normals or render two sides we have to get the colors
       if( displayNormals || colorTwoSides )
       {
         //get colors
         float frontColor[3] = { 0.0, 0.0, 1.0 };
         node->GetColor( frontColor, renderer, "front color" );
         float backColor[3] = { 1.0, 0.0, 0.0 };
         node->GetColor( backColor, renderer, "back color" );
 
         if ( displayNormals )
         {
           m_NormalsTransformer->SetInputData( surface->GetVtkPolyData() );
           m_NormalsTransformer->SetTransform(node->GetVtkTransform(this->GetTimestep()) );
 
           m_FrontHedgeHog->SetInputConnection(m_NormalsTransformer->GetOutputPort() );
           m_FrontHedgeHog->SetVectorModeToUseNormal();
           m_FrontHedgeHog->SetScaleFactor( invertNormals ? 1.0 : -1.0 );
           m_FrontHedgeHog->Update();
 
           m_FrontNormalsActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
 
           m_BackHedgeHog->SetInputConnection( m_NormalsTransformer->GetOutputPort() );
           m_BackHedgeHog->SetVectorModeToUseNormal();
           m_BackHedgeHog->SetScaleFactor( invertNormals ? -1.0 : 1.0 );
           m_BackHedgeHog->Update();
 
           m_BackNormalsActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
 
           //if there is no actor added yet, add one
           if ( !m_NormalsActorAdded )
           {
             m_Prop3DAssembly->AddPart( m_FrontNormalsActor );
             m_Prop3DAssembly->AddPart( m_BackNormalsActor );
             m_NormalsActorAdded = true;
           }
         }
         //if we don't want to display normals AND there is an actor added remove the actor
         else if ( m_NormalsActorAdded )
         {
           m_Prop3DAssembly->RemovePart( m_FrontNormalsActor );
           m_Prop3DAssembly->RemovePart( m_BackNormalsActor );
           m_NormalsActorAdded = false;
         }
 
         if ( colorTwoSides )
         {
           if ( !invertNormals )
           {
             m_BackgroundActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
             m_BackgroundActor->GetBackfaceProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
           }
           else
           {
             m_BackgroundActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
             m_BackgroundActor->GetBackfaceProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
           }
         }
       }
 
       // Add black background for all images (which may be transparent)
       m_BackgroundMapper->SetInputData( surface->GetVtkPolyData() );
       m_ImageAssembly->AddPart( m_BackgroundActor );
 
       LayerSortedActorList layerSortedActors;
 
       // Traverse the data tree to find nodes resliced by ImageMapperGL2D
       //use a predicate to get all data nodes which are "images" or inherit from mitk::Image
       mitk::TNodePredicateDataType< mitk::Image >::Pointer predicateAllImages = mitk::TNodePredicateDataType< mitk::Image >::New();
       mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetSubset(predicateAllImages);
       //process all found images
       for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
       {
 
         DataNode *node = it->Value();
         if (node != NULL)
           this->ProcessNode(node, renderer, surface, layerSortedActors);
       }
 
       // Add all image actors to the assembly, sorted according to
       // layer property
       LayerSortedActorList::iterator actorIt;
       for ( actorIt = layerSortedActors.begin(); actorIt != layerSortedActors.end(); ++actorIt )
       {
         m_ImageAssembly->AddPart( actorIt->second );
       }
 
       // Configurate the tube-shaped frame: size according to the surface
       // bounds, color as specified in the plane's properties
       vtkPolyData *surfacePolyData = surface->GetVtkPolyData();
       m_Cleaner->SetInputData(surfacePolyData);
       m_EdgeTransformer->SetTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
 
       // Adjust the radius according to extent
       m_EdgeTuber->SetRadius( tubeRadius );
 
       // Get the plane's color and set the tube properties accordingly
       ColorProperty::Pointer colorProperty;
       colorProperty = dynamic_cast<ColorProperty*>(this->GetDataNode()->GetProperty( "color" ));
       if ( colorProperty.IsNotNull() )
       {
         const Color& color = colorProperty->GetColor();
         m_EdgeActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
       }
       else
       {
         m_EdgeActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
       }
 
       m_ImageAssembly->SetUserTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
     }
 
     VtkRepresentationProperty* representationProperty;
     this->GetDataNode()->GetProperty(representationProperty, "material.representation", renderer);
     if ( representationProperty != NULL )
       m_BackgroundActor->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
   }
 
-  void Geometry2DDataVtkMapper3D::ProcessNode( DataNode * node, BaseRenderer* renderer,
+  void PlaneGeometryDataVtkMapper3D::ProcessNode( DataNode * node, BaseRenderer* renderer,
                                                Surface * surface, LayerSortedActorList &layerSortedActors )
   {
     if ( node != NULL )
     {
       //we need to get the information from the 2D mapper to render the texture on the 3D plane
       ImageVtkMapper2D *imageMapper = dynamic_cast< ImageVtkMapper2D * >( node->GetMapper(1) ); //GetMapper(1) provides the 2D mapper for the data node
 
       //if there is a 2D mapper, which is not the standard image mapper...
       if(!imageMapper && node->GetMapper(1))
       { //... check if it is the composite mapper
         std::string cname(node->GetMapper(1)->GetNameOfClass());
         if(!cname.compare("CompositeMapper")) //string.compare returns 0 if the two strings are equal.
         {
           //get the standard image mapper.
           //This is a special case in MITK and does only work for the CompositeMapper.
           imageMapper = dynamic_cast<ImageVtkMapper2D* >( node->GetMapper(3) );
         }
       }
 
       if ( (node->IsVisible(renderer)) && imageMapper )
       {
         WeakPointerProperty::Pointer rendererProp =
             dynamic_cast< WeakPointerProperty * >(GetDataNode()->GetPropertyList()->GetProperty("renderer"));
 
         if ( rendererProp.IsNotNull() )
         {
           BaseRenderer::Pointer planeRenderer = dynamic_cast< BaseRenderer * >(rendererProp->GetWeakPointer().GetPointer());
           // Retrieve and update image to be mapped
           const ImageVtkMapper2D::LocalStorage* localStorage = imageMapper->GetLocalStorage(planeRenderer);
 
           if ( planeRenderer.IsNotNull() )
           {
             // perform update of imagemapper if needed (maybe the respective 2D renderwindow is not rendered/update before)
             imageMapper->Update(planeRenderer);
 
             // If it has not been initialized already in a previous pass,
             // generate an actor and a texture object to
             // render the image associated with the ImageVtkMapper2D.
             vtkActor *imageActor;
             vtkDataSetMapper *dataSetMapper = NULL;
             vtkTexture *texture;
             if ( m_ImageActors.count( imageMapper ) == 0 )
             {
               dataSetMapper = vtkDataSetMapper::New();
               //Enable rendering without copying the image.
               dataSetMapper->ImmediateModeRenderingOn();
 
               texture = vtkNeverTranslucentTexture::New();
               texture->RepeatOff();
 
               imageActor = vtkActor::New();
               imageActor->SetMapper( dataSetMapper );
               imageActor->SetTexture( texture );
               imageActor->GetProperty()->SetOpacity(0.999); // HACK! otherwise VTK wouldn't recognize this as translucent surface (if LUT values map to alpha < 255
               // improvement: apply "opacity" property onle HERE and also in 2D image mapper. DO NOT change LUT to achieve translucent images (see method ChangeOpacity in image mapper 2D)
 
               // Make imageActor the sole owner of the mapper and texture
               // objects
               dataSetMapper->UnRegister( NULL );
               texture->UnRegister( NULL );
 
               // Store the actor so that it may be accessed in following
               // passes.
               m_ImageActors[imageMapper].Initialize(imageActor, imageMapper, m_ImageMapperDeletedCommand);
             }
             else
             {
               // Else, retrieve the actor and associated objects from the
               // previous pass.
               imageActor = m_ImageActors[imageMapper].m_Actor;
               dataSetMapper = (vtkDataSetMapper *)imageActor->GetMapper();
               texture = imageActor->GetTexture();
             }
 
             // Set poly data new each time its object changes (e.g. when
             // switching between planar and curved geometries)
             if ( (dataSetMapper != NULL) && (dataSetMapper->GetInput() != surface->GetVtkPolyData()) )
             {
               dataSetMapper->SetInputData( surface->GetVtkPolyData() );
             }
 
             dataSetMapper->Update();
 
             //Check if the m_ReslicedImage is NULL.
             //This is the case when no image geometry is met by
             //the reslicer. In that case, the texture has to be
             //empty (black) and we don't have to do anything.
             //See fixed bug #13275
             if(localStorage->m_ReslicedImage != NULL)
             {
               texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
 
               // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
               texture->MapColorScalarsThroughLookupTableOff();
 
               //re-use properties from the 2D image mapper
               imageActor->SetProperty( localStorage->m_Actor->GetProperty() );
               imageActor->GetProperty()->SetAmbient(0.5);
 
               // Set texture interpolation on/off
               bool textureInterpolation = node->IsOn( "texture interpolation", renderer );
               texture->SetInterpolate( textureInterpolation );
 
               // Store this actor to be added to the actor assembly, sort
               // by layer
               int layer = 1;
               node->GetIntProperty( "layer", layer );
               layerSortedActors.insert(std::pair< int, vtkActor * >( layer, imageActor ) );
             }
           }
         }
       }
     }
   }
 
-  void Geometry2DDataVtkMapper3D::ActorInfo::Initialize(vtkActor* actor, itk::Object* sender, itk::Command* command)
+  void PlaneGeometryDataVtkMapper3D::ActorInfo::Initialize(vtkActor* actor, itk::Object* sender, itk::Command* command)
   {
     m_Actor = actor;
     m_Sender = sender;
     // Get informed when ImageMapper object is deleted, so that
     // the data structures built here can be deleted as well
     m_ObserverID = sender->AddObserver( itk::DeleteEvent(), command );
   }
 
-  Geometry2DDataVtkMapper3D::ActorInfo::ActorInfo() : m_Actor(NULL), m_Sender(NULL), m_ObserverID(0)
+  PlaneGeometryDataVtkMapper3D::ActorInfo::ActorInfo() : m_Actor(NULL), m_Sender(NULL), m_ObserverID(0)
   {
   }
 
-  Geometry2DDataVtkMapper3D::ActorInfo::~ActorInfo()
+  PlaneGeometryDataVtkMapper3D::ActorInfo::~ActorInfo()
   {
     if(m_Sender != NULL)
     {
       m_Sender->RemoveObserver(m_ObserverID);
     }
     if(m_Actor != NULL)
     {
       m_Actor->Delete();
     }
   }
 } // namespace mitk
diff --git a/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.h b/Core/Code/Rendering/mitkPlaneGeometryDataVtkMapper3D.h
similarity index 91%
rename from Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.h
rename to Core/Code/Rendering/mitkPlaneGeometryDataVtkMapper3D.h
index d71ac0a672..14bfb05d60 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.h
+++ b/Core/Code/Rendering/mitkPlaneGeometryDataVtkMapper3D.h
@@ -1,212 +1,212 @@
 /*===================================================================
 
 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 MITKGEOMETRY2DDATAVTKMAPPER3D_H_HEADER_INCLUDED_C196C71F
 #define MITKGEOMETRY2DDATAVTKMAPPER3D_H_HEADER_INCLUDED_C196C71F
 
 #include <MitkCoreExports.h>
 #include "mitkVtkMapper.h"
 #include "mitkDataStorage.h"
-#include "mitkGeometry2DDataToSurfaceFilter.h"
+#include "mitkPlaneGeometryDataToSurfaceFilter.h"
 #include "mitkWeakPointer.h"
 
 #include <vtkSystemIncludes.h>
 #include <vtkCleanPolyData.h>
 
 class vtkActor;
 class vtkPolyDataMapper;
 class vtkAssembly;
 class vtkFeatureEdges;
 class vtkTubeFilter;
 class vtkTransformPolyDataFilter;
 class vtkHedgeHog;
 
 namespace mitk {
 
-class Geometry2DData;
+class PlaneGeometryData;
 class BaseRenderer;
 class ImageVtkMapper2D;
 class DataStorage;
 
 /**
  *  \brief Vtk-based mapper to display a PlaneGeometry in a 3D window
  *  \ingroup Mapper
  *
- *  Uses a Geometry2DDataToSurfaceFilter object to create a vtkPolyData representation of a given PlaneGeometry instance.
+ *  Uses a PlaneGeometryDataToSurfaceFilter object to create a vtkPolyData representation of a given PlaneGeometry instance.
  *  PlaneGeometry may either contain a common flat plane or a curved plane (ThinPlateSplineCurvedGeometry).
  *
  *  The vtkPolyData object is then decorated by a colored tube on the edges and by image textures if possible
  *  (currently this requires that there is a 2D render window rendering the same geometry as this mapper).
  *
  * Properties that influence rendering are:
  *
  *   - \b "draw edges": (Bool) Toggle display of the tubed frame
  *   - \b "color": (ColorProperty) Color of the tubed frame.
  *   - \b "xresolution": (FloatProperty) Resolution (=number of tiles) in x direction. Only relevant for ThinPlateSplineCurvedGeometry
  *   - \b "yresolution": (FloatProperty) Resolution (=number of tiles) in y direction. Only relevant for ThinPlateSplineCurvedGeometry
  *   - \b "draw normals 3D": (BoolProperty) If true, a vtkHedgeHog is used to display normals for the generated surface object. Useful to distinguish front and back of a plane. Hedgehogs are colored according to "front color" and "back color"
  *   - \b "color two sides": (BoolProperty) If true, front and back side of the plane are colored differently ("front color" and "back color")
  *   - \b "invert normals": (BoolProperty) Inverts front/back for display.
  *   - \b "front color": (ColorProperty) Color for front side of the plane
  *   - \b "back color": (ColorProperty) Color for back side of the plane
  *   - \b "material.representation": (BoolProperty) Choose the representation to draw the mesh in (Surface, Wireframe, Point Cloud)
  *   - \b "surfacegeometry": TODO: Add documentation
  *   - \b "LookupTable": (LookupTableProperty) Set the lookuptable to render with.
  *
  *  Note: The following properties are set for each image individually, and thus, also influence the rendering of this mapper:
  *
  *   - \b "texture interpolation": (BoolProperty) Turn on/off the texture interpolation of each image
  *   - \b "use color": (BoolProperty) Decide whether we want to use the color property or a lookuptable.
  *   - \b "binary": (BoolProperty) Binary image handling: Color the value=1.0 with the color property and make the background (value=0.0) of the image translucent.
  *   - \b "layer": (IntProperty) Controls what image is considered "on top" of another. In the case that two should inhabit the same space, higher layer occludes lower layer.
  *   - \b "opacity": (FloatProperty) Set the opacity for each rendered image.
  *   - \b "color": (FloatProperty) Set the color for each rendered image.
  *
  *  The internal filter pipeline which combines a (sometimes deformed) 2D surface
  *  with a nice frame and image textures is illustrated in the following sketch:
  *
- *  \image html mitkGeometry2DDataVtkMapper3D.png "Internal filter pipeline"
+ *  \image html mitkPlaneGeometryDataVtkMapper3D.png "Internal filter pipeline"
  *
  */
-class MITK_CORE_EXPORT Geometry2DDataVtkMapper3D : public VtkMapper
+class MITK_CORE_EXPORT PlaneGeometryDataVtkMapper3D : public VtkMapper
 {
 public:
-  mitkClassMacro(Geometry2DDataVtkMapper3D, VtkMapper);
+  mitkClassMacro(PlaneGeometryDataVtkMapper3D, VtkMapper);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /**
    * Overloaded since the displayed color-frame of the image mustn't be
    * transformed after generation of poly data, but before (vertex coordinates
    * only)
    */
   virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer);
   virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer);
 
   /**
-   *  \brief Get the Geometry2DData to map
+   *  \brief Get the PlaneGeometryData to map
    */
-  virtual const Geometry2DData *GetInput();
+  virtual const PlaneGeometryData *GetInput();
 
   /**
    * \brief All images found when traversing the (sub-) tree starting at
    * \a iterator which are resliced by an ImageVtkMapper2D will be mapped.
    * This method is used to set the data storage to traverse. This offers
    * the possibility to use this mapper for other data storages (not only
    * the default data storage).
    */
   virtual void SetDataStorageForTexture(mitk::DataStorage* storage);
 
 protected:
 
   typedef std::multimap< int, vtkActor * > LayerSortedActorList;
 
-  Geometry2DDataVtkMapper3D();
+  PlaneGeometryDataVtkMapper3D();
 
-  virtual ~Geometry2DDataVtkMapper3D();
+  virtual ~PlaneGeometryDataVtkMapper3D();
 
   virtual void GenerateDataForRenderer(BaseRenderer* renderer);
 
   void ProcessNode( DataNode * node, BaseRenderer* renderer, Surface * surface, LayerSortedActorList &layerSortedActors );
 
   void ImageMapperDeletedCallback( itk::Object *caller, const itk::EventObject &event );
 
   /** \brief general PropAssembly to hold the entire scene */
   vtkAssembly *m_Prop3DAssembly;
 
   /** \brief PropAssembly to hold the planes */
   vtkAssembly *m_ImageAssembly;
 
-  Geometry2DDataToSurfaceFilter::Pointer m_SurfaceCreator;
+  PlaneGeometryDataToSurfaceFilter::Pointer m_SurfaceCreator;
 
   BoundingBox::Pointer m_SurfaceCreatorBoundingBox;
 
   BoundingBox::PointsContainer::Pointer m_SurfaceCreatorPointsContainer;
 
   /** \brief Edge extractor for tube-shaped frame */
   vtkFeatureEdges *m_Edges;
 
   /** \brief Filter to apply object transform to the extracted edges */
   vtkTransformPolyDataFilter *m_EdgeTransformer;
 
   /** \brief Source to create the tube-shaped frame  */
   vtkTubeFilter *m_EdgeTuber;
 
   /** \brief Mapper for the tube-shaped frame  */
   vtkPolyDataMapper *m_EdgeMapper;
 
   /** \brief Actor for the tube-shaped frame */
   vtkActor *m_EdgeActor;
 
   /** \brief Mapper for black plane background */
   vtkPolyDataMapper *m_BackgroundMapper;
 
   /** \brief Actor for black plane background */
   vtkActor *m_BackgroundActor;
 
   /** \brief Transforms the suface before applying the glyph filter */
   vtkTransformPolyDataFilter* m_NormalsTransformer;
 
   /** \brief Mapper for normals representation (thin lines) */
   vtkPolyDataMapper* m_FrontNormalsMapper;
   vtkPolyDataMapper* m_BackNormalsMapper;
 
   /** \brief  Generates lines for surface normals */
   vtkHedgeHog* m_FrontHedgeHog;
   vtkHedgeHog* m_BackHedgeHog;
 
   /** \brief Actor to hold the normals arrows */
   vtkActor* m_FrontNormalsActor;
   vtkActor* m_BackNormalsActor;
 
   /** Cleans the polyline in order to avoid phantom boundaries */
   vtkCleanPolyData *m_Cleaner;
 
   /** Internal flag, if actors for normals are already added to m_Prop3DAssembly*/
   bool m_NormalsActorAdded;
 
   /** \brief The DataStorage defines which part of the data tree is traversed for renderering. */
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
 
   class MITK_CORE_EXPORT ActorInfo
   {
   public:
     vtkActor * m_Actor;
     // we do not need a smart-pointer, because we delete our
     // connection, when the referenced mapper is destroyed
     itk::Object* m_Sender;
     unsigned long m_ObserverID;
 
     void Initialize(vtkActor* actor, itk::Object* sender, itk::Command* command);
 
     ActorInfo();
     ~ActorInfo();
   };
 
   /** \brief List holding the vtkActor to map the image into 3D for each
    * ImageMapper
    */
   typedef std::map< ImageVtkMapper2D *, ActorInfo > ActorList;
   ActorList m_ImageActors;
 
   // responsiblity to remove the observer upon its destruction
-  typedef itk::MemberCommand< Geometry2DDataVtkMapper3D > MemberCommandType;
+  typedef itk::MemberCommand< PlaneGeometryDataVtkMapper3D > MemberCommandType;
   MemberCommandType::Pointer m_ImageMapperDeletedCommand;
 };
 } // namespace mitk
 #endif /* MITKGEOMETRY2DDATAVTKMAPPER3D_H_HEADER_INCLUDED_C196C71F */
diff --git a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
index 73842710f5..337becb949 100644
--- a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
@@ -1,524 +1,524 @@
 /*===================================================================
 
 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 "mitkPointSetGLMapper2D.h"
 #include "mitkPointSet.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "vtkLinearTransform.h"
 #include "mitkStringProperty.h"
 #include "mitkPointSet.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkGL.h"
 
 //const float selectedColor[]={1.0,0.0,0.6}; //for selected!
 
 
 mitk::PointSetGLMapper2D::PointSetGLMapper2D()
 : m_Polygon(false),
   m_ShowPoints(true),
   m_ShowDistances(false),
   m_DistancesDecimalDigits(1),
   m_ShowAngles(false),
   m_ShowDistantLines(true),
   m_LineWidth(1)
 {
 }
 
 
 mitk::PointSetGLMapper2D::~PointSetGLMapper2D()
 {
 }
 
 
 const mitk::PointSet *mitk::PointSetGLMapper2D::GetInput(void)
 {
   return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
 }
 
 
 void mitk::PointSetGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
 {
   GLMapper::ApplyColorAndOpacityProperties( renderer );
 
   const mitk::DataNode* node=GetDataNode();
   if( node == NULL )
     return;
 
   node->GetBoolProperty("show contour",            m_Polygon);
   node->GetBoolProperty("close contour",            m_PolygonClosed);
   node->GetBoolProperty("show points",        m_ShowPoints);
   node->GetBoolProperty("show distances",     m_ShowDistances);
   node->GetIntProperty("distance decimal digits",     m_DistancesDecimalDigits);
   node->GetBoolProperty("show angles",        m_ShowAngles);
   node->GetBoolProperty("show distant lines", m_ShowDistantLines);
   node->GetIntProperty("line width",          m_LineWidth);
   node->GetIntProperty("point line width",    m_PointLineWidth);
   node->GetIntProperty("point 2D size",       m_Point2DSize);
 }
 
 
 
 static bool makePerpendicularVector2D(const mitk::Vector2D& in, mitk::Vector2D& out)
 {
   if((fabs(in[0])>0) && ( (fabs(in[0])>fabs(in[1])) || (in[1] == 0) ) )
   {
     out[0]=-in[1]/in[0];
     out[1]=1;
     out.Normalize();
     return true;
   }
   else
   if(fabs(in[1])>0)
   {
     out[0]=1;
     out[1]=-in[0]/in[1];
     out.Normalize();
     return true;
   }
   else
     return false;
 }
 
 
 void mitk::PointSetGLMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
 
   const mitk::DataNode* node=GetDataNode();
   if( node == NULL )
     return;
 
   const int text2dDistance = 10;
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible) return;
 
   // @FIXME: Logik fuer update
   bool updateNeccesary=true;
 
   if (updateNeccesary)
   {
     // ok, das ist aus GenerateData kopiert
     mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
     // Get the TimeGeometry of the input object
     const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
     if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
     {
       return;
     }
 
     //
     // get the world time
     //
-    const PlaneGeometry* worldGeometry = renderer->GetCurrentWorldGeometry2D();
+    const PlaneGeometry* worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
     assert( worldGeometry != NULL );
     ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
 
     //
     // convert the world time in time steps of the input object
     //
     int timeStep=0;
     if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
       timeStep = inputTimeGeometry->TimePointToTimeStep( time );
     if ( inputTimeGeometry->IsValidTimeStep( timeStep ) == false )
     {
       return;
     }
 
 
     mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timeStep );
 
     if ( itkPointSet.GetPointer() == NULL)
     {
       return;
     }
 
 
     mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
 
     assert(displayGeometry.IsNotNull());
 
     //apply color and opacity read from the PropertyList
     this->ApplyAllProperties(renderer);
 
     vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
 
     //List of the Points
     PointSet::DataType::PointsContainerConstIterator it, end;
     it = itkPointSet->GetPoints()->Begin();
     end = itkPointSet->GetPoints()->End();
 
     //iterator on the additional data of each point
     PointSet::DataType::PointDataContainerIterator selIt, selEnd;
     bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
     selIt = itkPointSet->GetPointData()->Begin();
     selEnd = itkPointSet->GetPointData()->End();
 
     int counter = 0;
 
     //for writing text
     int j = 0;
 
     //for switching back to old color after using selected color
     float recallColor[4];
     glGetFloatv(GL_CURRENT_COLOR,recallColor);
 
     //get the properties for coloring the points
     float unselectedColor[4] = {1.0, 1.0, 0.0, 1.0};//yellow
     //check if there is an unselected property
     if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
       unselectedColor[0] = tmpColor[0];
       unselectedColor[1] = tmpColor[1];
       unselectedColor[2] = tmpColor[2];
       unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
     }
     else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
       unselectedColor[0] = tmpColor[0];
       unselectedColor[1] = tmpColor[1];
       unselectedColor[2] = tmpColor[2];
       unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
     }
     else
     {
       //get the color from the dataNode
       node->GetColor(unselectedColor, NULL);
     }
 
     //get selected property
     float selectedColor[4] = {1.0, 0.0, 0.6, 1.0};
     if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f;
     }
     else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f;
     }
 
     //check if there is an pointLineWidth property
     if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point line width")) != NULL)
     {
       m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point line width"))->GetValue();
     }
     else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point line width")) != NULL)
     {
       m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point line width"))->GetValue();
     }
 
     //check if there is an point 2D size property
     if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point 2D size")) != NULL)
     {
       m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point 2D size"))->GetValue();
     }
     else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point 2D size")) != NULL)
     {
       m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point 2D size"))->GetValue();
     }
 
     Point3D p;                      // currently visited point
     Point3D lastP;                  // last visited point
     Vector3D vec;                   // p - lastP
     Vector3D lastVec;               // lastP - point before lastP
     vec.Fill(0);
 
     mitk::Point3D projected_p;      // p projected on viewplane
 
     Point2D pt2d;       // projected_p in display coordinates
     Point2D lastPt2d;   // last projected_p in display coordinates
     Point2D preLastPt2d;// projected_p in display coordinates before lastPt2d
 
     Point2D lastPt2DInPointSet; // The last point in the pointset in display coordinates
     mitk::PointSet::DataType::PointType plob;
     plob.Fill(0);
     itkPointSet->GetPoint( itkPointSet->GetNumberOfPoints()-1, &plob);
 
     //map lastPt2DInPointSet to display coordinates
     float vtkp[3];
 
     itk2vtk(plob, vtkp);
     transform->TransformPoint(vtkp, vtkp);
     vtk2itk(vtkp,p);
 
     displayGeometry->Project(p, projected_p);
 
     displayGeometry->Map(projected_p, lastPt2DInPointSet);
     displayGeometry->WorldToDisplay(lastPt2DInPointSet, lastPt2DInPointSet);
 
     while(it!=end) // iterate over all points
     {
       lastP = p;        // valid only for counter > 0
       lastVec = vec;    // valid only for counter > 1
 
       preLastPt2d = lastPt2d; // valid only for counter > 1
       lastPt2d = pt2d;  // valid only for counter > 0
 
 
       itk2vtk(it->Value(), vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       vec = p-lastP;    // valid only for counter > 0
 
       displayGeometry->Project(p, projected_p);
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetSquaredNorm();
 
       //MouseOrientation
       bool isInputDevice=false;
 
       bool isRendererSlice = scalardiff < 0.00001; //cause roundoff error
       if(this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice && !isRendererSlice )
       {
         displayGeometry->Map(projected_p, pt2d);
         displayGeometry->WorldToDisplay(pt2d, pt2d);
 
         //Point size depending of distance to slice
         /*float p_size = (1/scalardiff)*10*m_Point2DSize;
         if(p_size < m_Point2DSize * 0.6 )
           p_size = m_Point2DSize * 0.6 ;
         else if ( p_size > m_Point2DSize )
           p_size = m_Point2DSize;*/
         float p_size = (1/scalardiff)*100.0;
         if(p_size < 6.0 )
           p_size = 6.0 ;
         else if ( p_size > 10.0 )
           p_size = 10.0;
 
         //draw Point
         float opacity = (p_size<8)?0.3:1.0;//don't get the opacity from the node? Feature not a bug! Otehrwise the 2D cross is hardly seen.
         glColor4f(unselectedColor[0],unselectedColor[1],unselectedColor[2],opacity);
         glPointSize(p_size);
         //glShadeModel(GL_FLAT);
         glBegin (GL_POINTS);
           glVertex2dv(&pt2d[0]);
         glEnd ();
       }
 
       //for point set
       if(!isInputDevice && ( (scalardiff<4.0) || (m_Polygon)))
       {
         Point2D tmp;
         displayGeometry->Map(projected_p, pt2d);
         displayGeometry->WorldToDisplay(pt2d, pt2d);
 
         Vector2D horz,vert;
         horz[0]=(float)m_Point2DSize-scalardiff*2; horz[1]=0;
         vert[0]=0;                vert[1]=(float)m_Point2DSize-scalardiff*2;
 
         // now paint text if available
         if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()
               ->GetProperty("label")) != NULL)
         {
           const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
             this->GetDataNode()->GetProperty("label"))->GetValue();
           std::string l = pointLabel;
           if (input->GetSize()>1)
           {
             // char buffer[20];
             // sprintf(buffer,"%d",it->Index());
             std::stringstream ss;
             ss << it->Index();
             l.append(ss.str());
           }
           if (unselectedColor != NULL)
           {
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             float rgb[3];//yellow
             rgb[0] = unselectedColor[0]; rgb[1] = unselectedColor[1]; rgb[2] = unselectedColor[2];
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,rgb[0], rgb[1],rgb[2]);
           }
           else
           {
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,0.0,1.0,0.0);
           }
         }
 
         if((m_ShowPoints) && (scalardiff<4.0))
         {
           //check if the point is to be marked as selected
           if(selIt != selEnd || pointDataBroken)
           {
             bool addAsSelected = false;
             if (pointDataBroken)
               addAsSelected = false;
             else if (selIt->Value().selected)
               addAsSelected = true;
             else
               addAsSelected = false;
 
             if (addAsSelected)
             {
               horz[0]=(float)m_Point2DSize;
               vert[1]=(float)m_Point2DSize;
               glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);
               glLineWidth(m_PointLineWidth);
               //a diamond 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(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
               glPointSize(1);
               glBegin (GL_POINTS);
               tmp=pt2d;             glVertex2dv(&tmp[0]);
               glEnd ();
             }
             else //if not selected
             {
               glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
               glLineWidth(m_PointLineWidth);
               //drawing crosses
               glBegin (GL_LINES);
               tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
               tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
               tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
               tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
               glEnd ();
               glLineWidth(1);
             }
           }
         }
 
         bool drawLinesEtc = true;
         if (!m_ShowDistantLines && counter > 0) // check, whether this line should be drawn
         {
           ScalarType currentDistance = displayGeometry->GetWorldGeometry()->SignedDistance(p);
           ScalarType lastDistance =    displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
           if ( currentDistance * lastDistance > 0.5 ) // points on same side of plane
             drawLinesEtc = false;
         }
 
         // draw a line
         if ((m_Polygon && counter>0 && drawLinesEtc) ||
             (m_Polygon && m_PolygonClosed && drawLinesEtc))
         {
            if ((counter == 0) && ( m_PolygonClosed))
            {
                lastPt2d = lastPt2DInPointSet;
            }
 
            //get contour color property
            float contourColor[4] = {unselectedColor[0], unselectedColor[1], unselectedColor[2], unselectedColor[3]};//so if no property set, then use unselected color
            if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
            {
               mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
               contourColor[0] = tmpColor[0];
               contourColor[1] = tmpColor[1];
               contourColor[2] = tmpColor[2];
               contourColor[3] = 1.0f;
            }
            else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
            {
               mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
               contourColor[0] = tmpColor[0];
               contourColor[1] = tmpColor[1];
               contourColor[2] = tmpColor[2];
               contourColor[3] = 1.0f;
            }
            //set this color
            glColor3f(contourColor[0],contourColor[1],contourColor[2]);
 
            glLineWidth( m_LineWidth );
            glBegin (GL_LINES);
            glVertex2dv(&pt2d[0]);
            glVertex2dv(&lastPt2d[0]);
            glEnd ();
            glLineWidth(1.0);
            if(m_ShowDistances) // calculate and print a distance
            {
               std::stringstream buffer;
               float distance = vec.GetNorm();
               buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distance<<" mm";
 
               Vector2D vec2d = pt2d-lastPt2d;
               makePerpendicularVector2D(vec2d, vec2d);
 
               Vector2D pos2d = (lastPt2d.GetVectorFromOrigin()+pt2d)*0.5+vec2d*text2dDistance;
 
               mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
               OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
               //this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
            }
 
            if(m_ShowAngles && counter > 1 ) // calculate and print the angle btw. two lines
            {
               std::stringstream buffer;
               //buffer << angle(vec.Get_vnl_vector(), -lastVec.Get_vnl_vector())*180/vnl_math::pi << "�";
               buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << (char)176;
 
               Vector2D vec2d = pt2d-lastPt2d;
               vec2d.Normalize();
               Vector2D lastVec2d = lastPt2d-preLastPt2d;
               lastVec2d.Normalize();
               vec2d=vec2d-lastVec2d;
               vec2d.Normalize();
 
               Vector2D pos2d = lastPt2d.GetVectorFromOrigin()+vec2d*text2dDistance*text2dDistance;
 
               mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
               OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
               //this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
            }
         }
         counter++;
       }
       ++it;
       if(selIt != selEnd && !pointDataBroken)
          ++selIt;
       j++;
     }
 
     //recall the color to the same color before this drawing
     glColor3f(recallColor[0],recallColor[1],recallColor[2]);
   }
 }
 
 void mitk::PointSetGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite ); // width of the line from one point to another
   node->AddProperty( "point line width", mitk::IntProperty::New(1), renderer, overwrite ); //width of the cross marking a point
   node->AddProperty( "point 2D size", mitk::IntProperty::New(8), renderer, overwrite ); // length of the cross marking a point // length of an edge of the box marking a point
   node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite ); // contour of the line between points
   node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite ); //show or hide points
   node->AddProperty( "show distances", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide distance measure (not always available)
   node->AddProperty( "distance decimal digits", mitk::IntProperty::New(2), renderer, overwrite ); //set the number of decimal digits to be shown
   node->AddProperty( "show angles", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide angle measurement (not always available)
   node->AddProperty( "show distant lines", mitk::BoolProperty::New(false), renderer, overwrite ); //show the line between to points from a distant view (equals "always on top" option)
   node->AddProperty( "layer", mitk::IntProperty::New(1), renderer, overwrite ); // default to draw pointset above images (they have a default layer of 0)
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp b/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
index f3022acda9..8792d257b6 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
@@ -1,716 +1,716 @@
 /*===================================================================
 
 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 "mitkPointSetVtkMapper2D.h"
 
 //mitk includes
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkPointSet.h"
 
 //vtk includes
 #include <vtkActor.h>
 #include <vtkPropAssembly.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkTransform.h>
 #include <vtkGlyph3D.h>
 #include <vtkTransformFilter.h>
 #include <vtkLine.h>
 #include <vtkGlyphSource2D.h>
 #include <vtkFloatArray.h>
 #include <vtkPointData.h>
 #include <vtkTextActor.h>
 #include <vtkTextProperty.h>
 #include <vtkCellArray.h>
 
 #include <stdlib.h>
 
 // constructor LocalStorage
 mitk::PointSetVtkMapper2D::LocalStorage::LocalStorage()
 {
   // points
   m_UnselectedPoints = vtkSmartPointer<vtkPoints>::New();
   m_SelectedPoints = vtkSmartPointer<vtkPoints>::New();
   m_ContourPoints = vtkSmartPointer<vtkPoints>::New();
 
   // scales
   m_UnselectedScales = vtkSmartPointer<vtkFloatArray>::New();
   m_SelectedScales = vtkSmartPointer<vtkFloatArray>::New();
 
   // distances
   m_DistancesBetweenPoints = vtkSmartPointer<vtkFloatArray>::New();
 
   // lines
   m_ContourLines = vtkSmartPointer<vtkCellArray>::New();
 
   // glyph source (provides the different shapes)
   m_UnselectedGlyphSource2D = vtkSmartPointer<vtkGlyphSource2D>::New();
   m_SelectedGlyphSource2D = vtkSmartPointer<vtkGlyphSource2D>::New();
 
   // glyphs
   m_UnselectedGlyph3D = vtkSmartPointer<vtkGlyph3D>::New();
   m_SelectedGlyph3D = vtkSmartPointer<vtkGlyph3D>::New();
 
   // polydata
   m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();
   m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   // actors
   m_UnselectedActor = vtkSmartPointer <vtkActor>::New();
   m_SelectedActor = vtkSmartPointer <vtkActor>::New();
   m_ContourActor = vtkSmartPointer <vtkActor>::New();
 
   // mappers
   m_VtkUnselectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_VtkSelectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_VtkContourPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
   // propassembly
   m_PropAssembly = vtkSmartPointer <vtkPropAssembly>::New();
 }
 // destructor LocalStorage
 mitk::PointSetVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 // input for this mapper ( = point set)
 const mitk::PointSet* mitk::PointSetVtkMapper2D::GetInput() const
 {
   return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
 }
 
 // constructor PointSetVtkMapper2D
 mitk::PointSetVtkMapper2D::PointSetVtkMapper2D()
 : m_ShowContour(false),
 m_CloseContour(false),
 m_ShowPoints(true),
 m_ShowDistances(false),
 m_DistancesDecimalDigits(1),
 m_ShowAngles(false),
 m_ShowDistantLines(false),
 m_LineWidth(1),
 m_PointLineWidth(1),
 m_Point2DSize(6),
 m_IDShapeProperty(mitk::PointSetShapeProperty::CROSS),
 m_FillShape(false),
 m_DistanceToPlane(4.0f)
 {
 }
 
 // destructor
 mitk::PointSetVtkMapper2D::~PointSetVtkMapper2D()
 {
 }
 
 // reset mapper so that nothing is displayed e.g. toggle visiblity of the propassembly
 void mitk::PointSetVtkMapper2D::ResetMapper( BaseRenderer* renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   ls->m_PropAssembly->VisibilityOff();
 }
 
 // returns propassembly
 vtkProp* mitk::PointSetVtkMapper2D::GetVtkProp(mitk::BaseRenderer * renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   return ls->m_PropAssembly;
 }
 
 static bool makePerpendicularVector2D(const mitk::Vector2D& in, mitk::Vector2D& out)
 {
   // The dot product of orthogonal vectors is zero.
   // In two dimensions the slopes of perpendicular lines are negative reciprocals.
   if((fabs(in[0])>0) && ( (fabs(in[0])>fabs(in[1])) || (in[1] == 0) ) )
   {
     // negative reciprocal
     out[0]=-in[1]/in[0];
     out[1]=1;
     out.Normalize();
     return true;
   }
   else
     if(fabs(in[1])>0)
     {
       out[0]=1;
       // negative reciprocal
       out[1]=-in[0]/in[1];
       out.Normalize();
       return true;
     }
     else
       return false;
 }
 
 void mitk::PointSetVtkMapper2D::CreateVTKRenderObjects(mitk::BaseRenderer* renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   unsigned i = 0;
 
   // The vtk text actors need to be removed manually from the propassembly
   // since the same vtk text actors are not overwriten within this function,
   // but new actors are added to the propassembly each time this function is executed.
   // Thus, the actors from the last call must be removed in the beginning.
   for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
   {
     if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextLabelActors.at(i)))
       ls->m_PropAssembly->RemovePart(ls->m_VtkTextLabelActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
   {
     if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextDistanceActors.at(i)))
       ls->m_PropAssembly->RemovePart(ls->m_VtkTextDistanceActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
   {
     if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextAngleActors.at(i)))
       ls->m_PropAssembly->RemovePart(ls->m_VtkTextAngleActors.at(i));
   }
 
   // initialize polydata here, otherwise we have update problems when
   // executing this function again
   ls->m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();
   ls->m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();
   ls->m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   // get input point set and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   // only update the input data, if the property tells us to
   bool update = true;
   this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
   if (update == true)
     input->Update();
 
   int timestep = this->GetTimestep();
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
 
   if ( itkPointSet.GetPointer() == NULL)
   {
     ls->m_PropAssembly->VisibilityOff();
     return;
   }
 
   //iterator for point set
   mitk::PointSet::PointsContainer::Iterator pointsIter = itkPointSet->GetPoints()->Begin();
 
   // PointDataContainer has additional information to each point, e.g. whether
   // it is selected or not
   mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   pointDataIter = itkPointSet->GetPointData()->Begin();
 
   //check if the list for the PointDataContainer is the same size as the PointsContainer.
   //If not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
   bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
 
   if( itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
   {
     ls->m_PropAssembly->VisibilityOff();
     return;
   }
 
   ls->m_PropAssembly->VisibilityOn();
 
   // empty point sets, cellarrays, scalars
   ls->m_UnselectedPoints->Reset();
   ls->m_SelectedPoints->Reset();
 
   ls->m_ContourPoints->Reset();
   ls->m_ContourLines->Reset();
 
   ls->m_UnselectedScales->Reset();
   ls->m_SelectedScales->Reset();
 
   ls->m_DistancesBetweenPoints->Reset();
 
   ls->m_VtkTextLabelActors.clear();
   ls->m_VtkTextDistanceActors.clear();
   ls->m_VtkTextAngleActors.clear();
 
   ls->m_UnselectedScales->SetNumberOfComponents(3);
   ls->m_SelectedScales->SetNumberOfComponents(3);
 
   int NumberContourPoints = 0;
   bool pointsOnSameSideOfPlane = false;
 
   const int text2dDistance = 10;
 
   // initialize points with a random start value
 
   // current point in point set
   itk::Point<ScalarType> point = pointsIter->Value();
 
   mitk::Point3D p = point;              // currently visited point
   mitk::Point3D lastP = point;          // last visited point (predecessor in point set of "point")
   mitk::Vector3D vec;                   // p - lastP
   mitk::Vector3D lastVec;               // lastP - point before lastP
   vec.Fill(0);
   lastVec.Fill(0);
 
   mitk::Point3D projected_p = point;     // p projected on viewplane
 
   mitk::Point2D pt2d;
   pt2d[0] = point[0];                    // projected_p in display coordinates
   pt2d[1] = point[1];
   mitk::Point2D lastPt2d = pt2d;         // last projected_p in display coordinates (predecessor in point set of "pt2d")
   mitk::Point2D preLastPt2d = pt2d ;     // projected_p in display coordinates before lastPt2
 
   mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
-  const mitk::PlaneGeometry* geo2D = renderer->GetCurrentWorldGeometry2D();
+  const mitk::PlaneGeometry* geo2D = renderer->GetCurrentWorldPlaneGeometry();
 
   vtkLinearTransform* dataNodeTransform = input->GetGeometry()->GetVtkTransform();
 
   int count = 0;
 
   for (pointsIter=itkPointSet->GetPoints()->Begin();
     pointsIter!=itkPointSet->GetPoints()->End();
     pointsIter++)
   {
     lastP = p; // valid for number of points count > 0
     preLastPt2d = lastPt2d; // valid only for count > 1
     lastPt2d = pt2d;  // valid for number of points count > 0
 
     lastVec = vec;    // valid only for counter > 1
 
     // get current point in point set
     point = pointsIter->Value();
 
     // transform point
     {
       float vtkp[3];
       itk2vtk(point, vtkp);
       dataNodeTransform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,point);
     }
 
     p[0] = point[0];
     p[1] = point[1];
     p[2] = point[2];
 
     displayGeometry->Project(p, projected_p);
     displayGeometry->Map(projected_p, pt2d);
     displayGeometry->WorldToDisplay(pt2d, pt2d);
 
     vec = p-lastP;    // valid only for counter > 0
 
     // compute distance to current plane
     float diff = geo2D->Distance(point);
     diff = diff * diff;
 
     // draw markers on slices a certain distance away from the points true location according to the tolerance threshold (m_DistanceToPlane)
     if(diff < m_DistanceToPlane)
     {
       // is point selected or not?
       if (pointDataIter->Value().selected)
       {
         ls->m_SelectedPoints->InsertNextPoint(point[0],point[1],point[2]);
         // point is scaled according to its distance to the plane
         ls->m_SelectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
       }
       else
       {
         ls->m_UnselectedPoints->InsertNextPoint(point[0],point[1],point[2]);
         // point is scaled according to its distance to the plane
         ls->m_UnselectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
       }
 
       //---- LABEL -----//
 
       //  paint label for each point if available
       if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetProperty("label")) != NULL)
       {
         const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
           this->GetDataNode()->GetProperty("label"))->GetValue();
         std::string l = pointLabel;
         if (input->GetSize()>1)
         {
           std::stringstream ss;
           ss << pointsIter->Index();
           l.append(ss.str());
         }
 
         ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
 
         ls->m_VtkTextActor->SetPosition(pt2d[0] + text2dDistance, pt2d[1] + text2dDistance);
         ls->m_VtkTextActor->SetInput(l.c_str());
         ls->m_VtkTextActor->GetTextProperty()->SetOpacity( 100 );
 
         float unselectedColor[4];
 
         //check if there is a color property
         GetDataNode()->GetColor(unselectedColor);
 
         if (unselectedColor != NULL)
           ls->m_VtkTextActor->GetTextProperty()->SetColor(unselectedColor[0], unselectedColor[1], unselectedColor[2]);
         else
           ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0f, 1.0f, 0.0f);
 
         ls->m_VtkTextLabelActors.push_back(ls->m_VtkTextActor);
       }
     }
 
     // draw contour, distance text and angle text in render window
 
     // lines between points, which intersect the current plane, are drawn
     if( m_ShowContour && count > 0 )
     {
       ScalarType distance =    displayGeometry->GetWorldGeometry()->SignedDistance(point);
       ScalarType lastDistance =    displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
 
       pointsOnSameSideOfPlane = (distance * lastDistance) > 0.5;
 
       // Points must be on different side of plane in order to draw a contour.
       // If "show distant lines" is enabled this condition is disregarded.
       if ( !pointsOnSameSideOfPlane || m_ShowDistantLines)
       {
         vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
 
         ls->m_ContourPoints->InsertNextPoint(lastP[0],lastP[1],lastP[2]);
         line->GetPointIds()->SetId(0, NumberContourPoints);
         NumberContourPoints++;
 
         ls->m_ContourPoints->InsertNextPoint(point[0], point[1], point[2]);
         line->GetPointIds()->SetId(1, NumberContourPoints);
         NumberContourPoints++;
 
         ls->m_ContourLines->InsertNextCell(line);
 
         if(m_ShowDistances) // calculate and print distance between adjacent points
         {
           float distancePoints = point.EuclideanDistanceTo(lastP);
 
           std::stringstream buffer;
           buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distancePoints<<" mm";
 
           // compute desired display position of text
           Vector2D vec2d = pt2d-lastPt2d;
           makePerpendicularVector2D(vec2d, vec2d); // text is rendered within text2dDistance perpendicular to current line
           Vector2D pos2d = (lastPt2d.GetVectorFromOrigin() + pt2d ) * 0.5 + vec2d * text2dDistance;
 
           ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
 
           ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
           ls->m_VtkTextActor->SetInput(buffer.str().c_str());
           ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
 
           ls->m_VtkTextDistanceActors.push_back(ls->m_VtkTextActor);
         }
 
         if(m_ShowAngles && count > 1) // calculate and print angle between connected lines
         {
           std::stringstream buffer;
           //(char) 176 is the degree sign
           buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << (char)176;
 
           //compute desired display position of text
           Vector2D vec2d = pt2d-lastPt2d;             // first arm enclosing the angle
           vec2d.Normalize();
           Vector2D lastVec2d = lastPt2d-preLastPt2d;  // second arm enclosing the angle
           lastVec2d.Normalize();
           vec2d=vec2d-lastVec2d;                      // vector connecting both arms
           vec2d.Normalize();
 
           // middle between two vectors that enclose the angle
           Vector2D pos2d = lastPt2d.GetVectorFromOrigin() + vec2d * text2dDistance * text2dDistance;
 
           ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
 
           ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
           ls->m_VtkTextActor->SetInput(buffer.str().c_str());
           ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
 
           ls->m_VtkTextAngleActors.push_back(ls->m_VtkTextActor);
         }
       }
     }
 
     if(pointDataIter != itkPointSet->GetPointData()->End())
     {
       pointDataIter++;
       count++;
     }
   }
 
   // add each single text actor to the assembly
   for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
   {
     ls->m_PropAssembly->AddPart(ls->m_VtkTextLabelActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
   {
     ls->m_PropAssembly->AddPart(ls->m_VtkTextDistanceActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
   {
     ls->m_PropAssembly->AddPart(ls->m_VtkTextAngleActors.at(i));
   }
 
   //---- CONTOUR -----//
 
   //create lines between the points which intersect the plane
   if (m_ShowContour)
   {
     // draw line between first and last point which is rendered
     if(m_CloseContour && NumberContourPoints > 1){
       vtkSmartPointer<vtkLine> closingLine = vtkSmartPointer<vtkLine>::New();
       closingLine->GetPointIds()->SetId(0, 0); // index of first point
       closingLine->GetPointIds()->SetId(1, NumberContourPoints-1); // index of last point
       ls->m_ContourLines->InsertNextCell(closingLine);
     }
 
     ls->m_VtkContourPolyData->SetPoints(ls->m_ContourPoints);
     ls->m_VtkContourPolyData->SetLines(ls->m_ContourLines);
 
     ls->m_VtkContourPolyDataMapper->SetInputData(ls->m_VtkContourPolyData);
     ls->m_ContourActor->SetMapper(ls->m_VtkContourPolyDataMapper);
     ls->m_ContourActor->GetProperty()->SetLineWidth(m_LineWidth);
 
     ls->m_PropAssembly->AddPart(ls->m_ContourActor);
   }
 
   // the point set must be transformed in order to obtain the appropriate glyph orientation
   // according to the current view
   vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> a,b = vtkSmartPointer<vtkMatrix4x4>::New();
 
   a = geo2D->GetVtkTransform()->GetMatrix();
   b->DeepCopy( a );
 
   // delete transformation from matrix, only take orientation
   b->SetElement(3,3,1);
   b->SetElement(2,3,0);
   b->SetElement(1,3,0);
   b->SetElement(0,3,0);
   b->SetElement(3,2,0);
   b->SetElement(3,1,0);
   b->SetElement(3,0,0);
 
   transform->SetMatrix(  b );
 
   //---- UNSELECTED POINTS  -----//
 
   // apply properties to glyph
   ls->m_UnselectedGlyphSource2D->SetGlyphType(m_IDShapeProperty);
 
   if(m_FillShape)
     ls->m_UnselectedGlyphSource2D->FilledOn();
   else
     ls->m_UnselectedGlyphSource2D->FilledOff();
 
   // apply transform
   vtkSmartPointer<vtkTransformFilter> transformFilterU = vtkSmartPointer<vtkTransformFilter>::New();
   transformFilterU->SetInputConnection(ls->m_UnselectedGlyphSource2D->GetOutputPort());
   transformFilterU->SetTransform(transform);
 
   ls->m_VtkUnselectedPointListPolyData->SetPoints(ls->m_UnselectedPoints);
   ls->m_VtkUnselectedPointListPolyData->GetPointData()->SetVectors(ls->m_UnselectedScales);
 
   // apply transform of current plane to glyphs
   ls->m_UnselectedGlyph3D->SetSourceConnection(transformFilterU->GetOutputPort());
   ls->m_UnselectedGlyph3D->SetInputData(ls->m_VtkUnselectedPointListPolyData);
   ls->m_UnselectedGlyph3D->SetScaleModeToScaleByVector();
   ls->m_UnselectedGlyph3D->SetVectorModeToUseVector();
 
   ls->m_VtkUnselectedPolyDataMapper->SetInputConnection(ls->m_UnselectedGlyph3D->GetOutputPort());
   ls->m_UnselectedActor->SetMapper(ls->m_VtkUnselectedPolyDataMapper);
   ls->m_UnselectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
 
   ls->m_PropAssembly->AddPart(ls->m_UnselectedActor);
 
   //---- SELECTED POINTS  -----//
 
   ls->m_SelectedGlyphSource2D->SetGlyphTypeToDiamond();
   ls->m_SelectedGlyphSource2D->CrossOn();
   ls->m_SelectedGlyphSource2D->FilledOff();
 
   // apply transform
   vtkSmartPointer<vtkTransformFilter> transformFilterS = vtkSmartPointer<vtkTransformFilter>::New();
   transformFilterS->SetInputConnection(ls->m_SelectedGlyphSource2D->GetOutputPort());
   transformFilterS->SetTransform(transform);
 
   ls->m_VtkSelectedPointListPolyData->SetPoints(ls->m_SelectedPoints);
   ls->m_VtkSelectedPointListPolyData->GetPointData()->SetVectors(ls->m_SelectedScales);
 
   // apply transform of current plane to glyphs
   ls->m_SelectedGlyph3D->SetSourceConnection(transformFilterS->GetOutputPort());
   ls->m_SelectedGlyph3D->SetInputData(ls->m_VtkSelectedPointListPolyData);
   ls->m_SelectedGlyph3D->SetScaleModeToScaleByVector();
   ls->m_SelectedGlyph3D->SetVectorModeToUseVector();
 
   ls->m_VtkSelectedPolyDataMapper->SetInputConnection(ls->m_SelectedGlyph3D->GetOutputPort());
   ls->m_SelectedActor->SetMapper(ls->m_VtkSelectedPolyDataMapper);
   ls->m_SelectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
 
   ls->m_PropAssembly->AddPart(ls->m_SelectedActor);
 }
 
 void mitk::PointSetVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   const mitk::DataNode* node = GetDataNode();
   if( node == NULL )
     return;
 
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   // check whether the input data has been changed
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   // toggle visibility
   bool visible = true;
   node->GetVisibility(visible, renderer, "visible");
   if(!visible)
   {
     ls->m_UnselectedActor->VisibilityOff();
     ls->m_SelectedActor->VisibilityOff();
     ls->m_ContourActor->VisibilityOff();
     ls->m_PropAssembly->VisibilityOff();
     return;
   }else{
     ls->m_PropAssembly->VisibilityOn();
   }
 
   node->GetBoolProperty("show contour",       m_ShowContour, renderer);
   node->GetBoolProperty("close contour",      m_CloseContour, renderer);
   node->GetBoolProperty("show points",        m_ShowPoints, renderer);
   node->GetBoolProperty("show distances",     m_ShowDistances, renderer);
   node->GetIntProperty("distance decimal digits",     m_DistancesDecimalDigits, renderer);
   node->GetBoolProperty("show angles",        m_ShowAngles, renderer);
   node->GetBoolProperty("show distant lines", m_ShowDistantLines, renderer);
   node->GetIntProperty("line width",          m_LineWidth, renderer);
   node->GetIntProperty("point line width",    m_PointLineWidth, renderer);
   node->GetIntProperty("point 2D size",       m_Point2DSize, renderer);
   node->GetBoolProperty("Pointset.2D.fill shape", m_FillShape, renderer);
   node->GetFloatProperty("Pointset.2D.distance to plane", m_DistanceToPlane, renderer );
 
   mitk::PointSetShapeProperty::Pointer shape = dynamic_cast<mitk::PointSetShapeProperty*>(this->GetDataNode()->GetProperty( "Pointset.2D.shape", renderer ));
   if(shape.IsNotNull())
   {
     m_IDShapeProperty = shape->GetPointSetShape();
   }
 
   //check for color props and use it for rendering of selected/unselected points and contour
   //due to different params in VTK (double/float) we have to convert
 
   float unselectedColor[4];
   double selectedColor[4]={1.0f,0.0f,0.0f,1.0f};    //red
   double contourColor[4]={1.0f,0.0f,0.0f,1.0f};     //red
 
   float opacity = 1.0;
 
   GetDataNode()->GetOpacity(opacity, renderer);
 
   // apply color and opacity
   if(m_ShowPoints)
   {
     ls->m_UnselectedActor->VisibilityOn();
     ls->m_SelectedActor->VisibilityOn();
 
     //check if there is a color property
     GetDataNode()->GetColor(unselectedColor);
 
     //get selected color property
     if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f; // alpha value
     }
     else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f; // alpha value
     }
 
     ls->m_SelectedActor->GetProperty()->SetColor(selectedColor);
     ls->m_SelectedActor->GetProperty()->SetOpacity(opacity);
 
     ls->m_UnselectedActor->GetProperty()->SetColor(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
     ls->m_UnselectedActor->GetProperty()->SetOpacity(opacity);
   }
   else
   {
     ls->m_UnselectedActor->VisibilityOff();
     ls-> m_SelectedActor->VisibilityOff();
   }
 
   if (m_ShowContour)
   {
     ls->m_ContourActor->VisibilityOn();
 
     //get contour color property
     if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
       contourColor[0] = tmpColor[0];
       contourColor[1] = tmpColor[1];
       contourColor[2] = tmpColor[2];
       contourColor[3] = 1.0f;
     }
     else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
       contourColor[0] = tmpColor[0];
       contourColor[1] = tmpColor[1];
       contourColor[2] = tmpColor[2];
       contourColor[3] = 1.0f;
     }
 
     ls->m_ContourActor->GetProperty()->SetColor(contourColor);
     ls->m_ContourActor->GetProperty()->SetOpacity(opacity);
   }
   else
   {
     ls->m_ContourActor->VisibilityOff();
   }
 
   if(needGenerateData)
   {
     // create new vtk render objects (e.g. a circle for a point)
     this->CreateVTKRenderObjects(renderer);
   }
 }
 
 void mitk::PointSetVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "point line width", mitk::IntProperty::New(1), renderer, overwrite );
   node->AddProperty( "point 2D size", mitk::IntProperty::New(6), renderer, overwrite );
   node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "show distances", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "distance decimal digits", mitk::IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "show angles", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "show distant lines", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "layer", mitk::IntProperty::New(1), renderer, overwrite );
   node->AddProperty( "Pointset.2D.fill shape", mitk::BoolProperty::New(false), renderer, overwrite); // fill or do not fill the glyph shape
   mitk::PointSetShapeProperty::Pointer pointsetShapeProperty = mitk::PointSetShapeProperty::New();
   node->AddProperty( "Pointset.2D.shape", pointsetShapeProperty, renderer, overwrite);
   node->AddProperty( "Pointset.2D.distance to plane", mitk::FloatProperty::New(4.0f), renderer, overwrite ); //show the point at a certain distance above/below the 2D imaging plane.
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
index 0dabdf6ed9..54908d40a8 100644
--- a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
@@ -1,544 +1,544 @@
 /*===================================================================
 
 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 <mitkGL.h>
 
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkSurface.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkLookupTableProperty.h"
 
 #include <vtkPolyData.h>
 #include <vtkPlane.h>
 #include <vtkCutter.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkLookupTable.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkDataArray.h>
 #include <vtkLinearTransform.h>
 #include <vtkAbstractMapper.h>
 #include <vtkPKdTree.h>
 #include <vtkStripper.h>
 
 
 mitk::SurfaceGLMapper2D::SurfaceGLMapper2D()
 : m_Plane( vtkPlane::New() ),
   m_Cutter( vtkCutter::New() ),
   m_LUT( vtkLookupTable::New() ),
   m_PointLocator( vtkPKdTree::New() ),
   m_Stripper( vtkStripper::New() ),
   m_DrawNormals(false),
   m_FrontNormalLengthInPixels(10.0),
   m_BackNormalLengthInPixels(10.0)
 {
   // default for normals on front side = green
   m_FrontSideColor[0] = 0.0;
   m_FrontSideColor[1] = 1.0;
   m_FrontSideColor[2] = 0.0;
   m_FrontSideColor[3] = 1.0;
 
   // default for normals on back side = red
   m_BackSideColor[0] = 1.0;
   m_BackSideColor[1] = 0.0;
   m_BackSideColor[2] = 0.0;
   m_BackSideColor[3] = 1.0;
 
   // default for line color = yellow
   m_LineColor[0] = 1.0;
   m_LineColor[1] = 1.0;
   m_LineColor[2] = 0.0;
   m_LineColor[3] = 1.0;
 
   m_Cutter->SetCutFunction(m_Plane);
   m_Cutter->GenerateValues(1,0,1);
 
   m_LUT->SetTableRange(0,255);
   m_LUT->SetNumberOfColors(255);
   m_LUT->SetRampToLinear();
   m_LUT->Build();
 }
 
 mitk::SurfaceGLMapper2D::~SurfaceGLMapper2D()
 {
   m_Plane->Delete();
   m_Cutter->Delete();
   m_LUT->Delete();
   m_PointLocator->Delete();
   m_Stripper->Delete();
 }
 
 const mitk::Surface *mitk::SurfaceGLMapper2D::GetInput(void)
 {
   if(m_Surface.IsNotNull())
     return m_Surface;
 
   return static_cast<const Surface * > ( GetDataNode()->GetData() );
 }
 
 void mitk::SurfaceGLMapper2D::SetDataNode( mitk::DataNode* node )
 {
   Superclass::SetDataNode( node );
 
   bool useCellData;
   if (dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring")) == NULL)
     useCellData = false;
   else
     useCellData = dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring"))->GetValue();
 
   if (!useCellData)
   {
     // search min/max point scalars over all time steps
     double dataRange[2] = {0,0};
     double range[2];
 
     Surface::Pointer input  = const_cast< Surface* >(dynamic_cast<const Surface*>( this->GetDataNode()->GetData() ));
     if(input.IsNull()) return;
     const TimeGeometry::Pointer inputTimeGeometry = input->GetTimeGeometry();
     if(( inputTimeGeometry.IsNull() ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) ) return;
     for (unsigned int timestep=0; timestep<inputTimeGeometry->CountTimeSteps(); timestep++)
     {
       vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
       if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 )) continue;
       vtkDataArray *vpointscalars = vtkpolydata->GetPointData()->GetScalars();
       if (vpointscalars) {
         vpointscalars->GetRange( range, 0 );
         if (dataRange[0]==0 && dataRange[1]==0) {
           dataRange[0] = range[0];
           dataRange[1] = range[1];
         }
         else {
           if (range[0] < dataRange[0]) dataRange[0] = range[0];
           if (range[1] > dataRange[1]) dataRange[1] = range[1];
         }
       }
     }
     if (dataRange[1] - dataRange[0] > 0) {
       m_LUT->SetTableRange( dataRange );
       m_LUT->Build();
     }
   }
 }
 
 
 void mitk::SurfaceGLMapper2D::Paint(mitk::BaseRenderer * renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if(!visible) return;
 
   Surface::Pointer input  = const_cast<Surface*>(this->GetInput());
 
   if(input.IsNull())
     return;
 
   //
   // get the TimeGeometry of the input object
   //
   const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
   if(( inputTimeGeometry == NULL ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
     return;
 
   if (dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width")) == NULL)
     m_LineWidth = 1;
   else
     m_LineWidth = dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width"))->GetValue();
 
   //
   // get the world time
   //
-  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
+  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   assert( worldGeometry.IsNotNull() );
 
   ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
   int timestep=0;
 
   if( time > ScalarTypeNumericTraits::NonpositiveMin() )
     timestep = inputTimeGeometry->TimePointToTimeStep( time );
 
  // int timestep = this->GetTimestep();
 
   if( inputTimeGeometry->IsValidTimeStep( timestep ) == false )
     return;
 
   vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
   if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 ))
     return;
 
   PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>(worldGeometry.GetPointer());
 
   //apply color and opacity read from the PropertyList
   this->ApplyAllProperties(renderer);
 
   if (m_DrawNormals)
   {
     m_PointLocator->SetDataSet( vtkpolydata );
     m_PointLocator->BuildLocatorFromPoints( vtkpolydata->GetPoints() );
   }
 
   if(vtkpolydata!=NULL)
   {
     Point3D point;
     Vector3D normal;
 
     //Check if Lookup-Table is already given, else use standard one.
     double* scalarLimits = m_LUT->GetTableRange();
     double scalarsMin = scalarLimits[0], scalarsMax = scalarLimits[1];
 
     vtkLookupTable *lut;
 
     LookupTableProperty::Pointer lookupTableProp;
     this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
     if (lookupTableProp.IsNotNull() )
     {
       lut = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
 
       if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
         scalarsMin = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
       if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
         scalarsMax = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
 
       // check if the scalar range has been changed, e.g. manually, for the data tree node, and rebuild the LUT if necessary.
       double* oldRange = lut->GetTableRange();
       if( oldRange[0] != scalarsMin || oldRange[1] != scalarsMax )
       {
         lut->SetTableRange(scalarsMin, scalarsMax);
         lut->Build();
       }
     }
     else
     {
       lut = m_LUT;
     }
 
     vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform(timestep);
     if(worldPlaneGeometry.IsNotNull())
     {
       // set up vtkPlane according to worldGeometry
       point=worldPlaneGeometry->GetOrigin();
       normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
       m_Plane->SetTransform((vtkAbstractTransform*)NULL);
     }
     else
     {
-      AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
+      AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldPlaneGeometry());
       if(worldAbstractGeometry.IsNotNull())
       {
         AbstractTransformGeometry::ConstPointer surfaceAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(input->GetTimeGeometry()->GetGeometryForTimeStep(0).GetPointer());
         if(surfaceAbstractGeometry.IsNotNull()) //@todo substitude by operator== after implementation, see bug id 28
         {
           PaintCells(renderer, vtkpolydata, worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut);
           return;
         }
         else
         {
           //@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "flat plane" into a "curved plane"?
           return;
           // set up vtkPlane according to worldGeometry
           point=const_cast<BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
           FillVector3D(normal, 0, 0, 1);
           m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
         }
       }
       else
         return;
     }
 
     double vp[3], vnormal[3];
 
     vnl2vtk(point.GetVnlVector(), vp);
     vnl2vtk(normal.GetVnlVector(), vnormal);
 
     //normally, we would need to transform the surface and cut the transformed surface with the cutter.
     //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
     //@todo It probably does not work for scaling operations yet:scaling operations have to be
     //dealed with after the cut is performed by scaling the contour.
     vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
     inversetransform->TransformPoint(vp, vp);
     inversetransform->TransformNormalAtPoint(vp, vnormal, vnormal);
 
     m_Plane->SetOrigin(vp);
     m_Plane->SetNormal(vnormal);
 
     //set data into cutter
     m_Cutter->SetInputData(vtkpolydata);
     m_Cutter->Update();
     //    m_Cutter->GenerateCutScalarsOff();
     //    m_Cutter->SetSortByToSortByCell();
 
     if (m_DrawNormals)
     {
       m_Stripper->SetInputData( m_Cutter->GetOutput() );
       // calculate the cut
       m_Stripper->Update();
       PaintCells(renderer, m_Stripper->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
     }
     else
     {
       PaintCells(renderer, m_Cutter->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
     }
   }
 }
 
 void mitk::SurfaceGLMapper2D::PaintCells(mitk::BaseRenderer* renderer, vtkPolyData* contour,
                                        const PlaneGeometry* worldGeometry,
                                        const DisplayGeometry* displayGeometry,
                                        vtkLinearTransform * vtktransform,
                                        vtkLookupTable *lut,
                                        vtkPolyData* original3DObject)
 {
   // deprecated settings
   bool usePointData = false;
 
   bool useCellData = false;
   this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", useCellData);
 
   bool scalarVisibility = false;
   this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
 
   if(scalarVisibility)
   {
     VtkScalarModeProperty* scalarMode;
     if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
     {
       if( (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA) ||
         (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT) )
       {
         usePointData = true;
       }
       if(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA)
       {
         useCellData = true;
       }
     }
     else
     {
       usePointData = true;
     }
   }
 
   vtkPoints    *vpoints = contour->GetPoints();
   vtkDataArray *vpointscalars = contour->GetPointData()->GetScalars();
 
   vtkCellArray *vlines  = contour->GetLines();
   vtkDataArray* vcellscalars = contour->GetCellData()->GetScalars();
 
   Point3D p; Point2D p2d, last;
   int i, j;
   int numberOfLines = vlines->GetNumberOfCells();
 
   glLineWidth( m_LineWidth );
   glBegin (GL_LINES);
 
   glColor4fv(m_LineColor);
 
   double distanceSinceLastNormal(0.0);
 
   vlines->InitTraversal();
   for(i=0;i<numberOfLines;++i)
   {
     vtkIdType *cell(NULL);
     vtkIdType cellSize(0);
     double vp[3];
 
     vlines->GetNextCell(cellSize, cell);
 
     vpoints->GetPoint(cell[0], vp);
     //take transformation via vtktransform into account
     vtktransform->TransformPoint(vp, vp);
     vtk2itk(vp, p);
 
     //convert 3D point (in mm) to 2D point on slice (also in mm)
     worldGeometry->Map(p, p2d);
 
     //convert point (until now mm and in world coordinates) to display coordinates (units )
     displayGeometry->WorldToDisplay(p2d, p2d);
     last=p2d;
 
     for(j=1; j<cellSize; ++j)
     {
       vpoints->GetPoint(cell[j], vp);
       Point3D originalPoint;
       vtk2itk(vp, originalPoint);
       //take transformation via vtktransform into account
       vtktransform->TransformPoint(vp, vp);
       vtk2itk(vp, p);
 
       //convert 3D point (in mm) to 2D point on slice (also in mm)
       worldGeometry->Map(p, p2d);
 
       //convert point (until now mm and in world coordinates) to display coordinates (units )
       displayGeometry->WorldToDisplay(p2d, p2d);
 
       double color[3];
       if (useCellData && vcellscalars != NULL )
       {
         // color each cell according to cell data
         lut->GetColor( vcellscalars->GetComponent(i,0),color);
         glColor3f(color[0],color[1],color[2]);
         glVertex2f(last[0], last[1]);
         glVertex2f(p2d[0], p2d[1]);
       }
       else if (usePointData && vpointscalars != NULL )
       {
         lut->GetColor( vpointscalars->GetComponent(cell[j-1],0),color);
         glColor3f(color[0],color[1],color[2]);
         glVertex2f(last[0], last[1]);
         lut->GetColor( vpointscalars->GetComponent(cell[j],0),color);
         glColor3f(color[0],color[1],color[2]);
         glVertex2f(p2d[0], p2d[1]);
       }
       else
       {
         glVertex2f(last[0], last[1]);
         glVertex2f(p2d[0], p2d[1]);
 
         // draw normals ?
         if (m_DrawNormals && original3DObject)
         {
           distanceSinceLastNormal += sqrt((p2d[0]-last[0])*(p2d[0]-last[0]) + (p2d[1]-last[1])*(p2d[1]-last[1]));
           if (distanceSinceLastNormal >= 5.0)
           {
             distanceSinceLastNormal = 0.0;
 
             vtkPointData* pointData = original3DObject->GetPointData();
             if (!pointData) break;
 
             vtkDataArray* normalsArray = pointData->GetNormals();
             if (!normalsArray) break;
 
             // find 3D point closest to the currently drawn point
             double distance(0.0);
             vtkIdType closestPointId = m_PointLocator->FindClosestPoint(originalPoint[0], originalPoint[1], originalPoint[2], distance);
             if (closestPointId >= 0)
             {
               // find normal of 3D object at this 3D point
               double* normal = normalsArray->GetTuple3(closestPointId);
               double transformedNormal[3];
               vtktransform->TransformNormal(normal, transformedNormal);
 
               Vector3D normalITK;
               vtk2itk(transformedNormal, normalITK);
               normalITK.Normalize();
 
               // calculate a point (point from the cut 3D object) + (normal vector of closest point)
               Point3D tip3D = p + normalITK;
 
               // map this point into our 2D coordinate system
               Point2D tip2D;
               worldGeometry->Map(tip3D, tip2D);
 
               displayGeometry->WorldToDisplay(tip2D, tip2D);
 
               // calculate 2D vector from point to point+normal, normalize it to standard length
               Vector2D tipVectorGLFront = tip2D - p2d;
               tipVectorGLFront.Normalize();
               tipVectorGLFront *= m_FrontNormalLengthInPixels;
 
               Vector2D tipVectorGLBack = p2d - tip2D;
               tipVectorGLBack.Normalize();
               tipVectorGLBack *= m_BackNormalLengthInPixels;
 
               Point2D tipPoint2D = p2d + tipVectorGLFront;
               Point2D backTipPoint2D = p2d + tipVectorGLBack;
 
               // draw normalized mapped normal vector
               glColor4f(m_BackSideColor[0], m_BackSideColor[1], m_BackSideColor[2], m_BackSideColor[3]); // red backside
               glVertex2f(p2d[0], p2d[1]);
               glVertex2f(tipPoint2D[0], tipPoint2D[1]);
               glColor4f(m_FrontSideColor[0], m_FrontSideColor[1], m_FrontSideColor[2], m_FrontSideColor[3]); // green backside
               glVertex2f(p2d[0], p2d[1]);
               glVertex2f(backTipPoint2D[0], backTipPoint2D[1]);
               glColor4fv(m_LineColor); // back to line color
             }
           }
         }
       }
       last=p2d;
     }
   }
 
   glEnd();
   glLineWidth(1.0);
 }
 
 void mitk::SurfaceGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "scalar mode", VtkScalarModeProperty::New(), renderer, overwrite );
   node->AddProperty( "draw normals 2D", BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "invert normals", BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "front color", ColorProperty::New(0.0, 1.0, 0.0), renderer, overwrite );
   node->AddProperty( "back color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite );
   node->AddProperty( "front normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
   node->AddProperty( "back normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
   node->AddProperty( "layer", mitk::IntProperty::New(100), renderer, overwrite);
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 void mitk::SurfaceGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
 {
   ApplyColorAndOpacityProperties(renderer);
 
   DataNode * node = GetDataNode();
 
   if(node == NULL)
   {
     return;
   }
 
   node->GetBoolProperty("draw normals 2D", m_DrawNormals, renderer);
 
   // check for color and opacity properties, use it for rendering if they exists
   node->GetColor(m_LineColor, renderer, "color");
   node->GetOpacity(m_LineColor[3], renderer, "opacity");
 
   bool invertNormals(false);
   node->GetBoolProperty("invert normals", invertNormals, renderer);
 
   if (!invertNormals)
   {
     node->GetColor(m_FrontSideColor, renderer, "front color");
     node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
 
     node->GetColor(m_BackSideColor, renderer, "back color");
     node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
 
     node->GetFloatProperty( "front normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
     node->GetFloatProperty( "back normal lenth (px)", m_BackNormalLengthInPixels, renderer );
 
   }
   else
   {
     node->GetColor(m_FrontSideColor, renderer, "back color");
     node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
 
     node->GetColor(m_BackSideColor, renderer, "front color");
     node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
 
     node->GetFloatProperty( "back normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
     node->GetFloatProperty( "front normal lenth (px)", m_BackNormalLengthInPixels, renderer );
 
   }
 }
 
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.cpp b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
index 2735f23325..7e453ff7d5 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.cpp
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
@@ -1,975 +1,975 @@
 /*===================================================================
 
 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 "mitkVtkPropRenderer.h"
 
 // MAPPERS
 #include "mitkMapper.h"
 #include "mitkImageVtkMapper2D.h"
 #include "mitkVtkMapper.h"
 #include "mitkGLMapper.h"
-#include "mitkGeometry2DDataVtkMapper3D.h"
+#include "mitkPlaneGeometryDataVtkMapper3D.h"
 
 #include "mitkImageSliceSelector.h"
 #include "mitkRenderingManager.h"
 #include "mitkGL.h"
 #include "mitkGeometry3D.h"
 #include "mitkDisplayGeometry.h"
 #include "mitkLevelWindow.h"
 #include "mitkCameraController.h"
 #include "mitkVtkInteractorCameraController.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 #include "mitkSurface.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkVtkInteractorStyle.h"
 
 // VTK
 #include <vtkRenderer.h>
 #include <vtkRendererCollection.h>
 #include <vtkLight.h>
 #include <vtkLightKit.h>
 #include <vtkRenderWindow.h>
 #include <vtkLinearTransform.h>
 #include <vtkCamera.h>
 #include <vtkWorldPointPicker.h>
 #include <vtkPointPicker.h>
 #include <vtkCellPicker.h>
 #include <vtkTextActor.h>
 #include <vtkTextProperty.h>
 #include <vtkProp.h>
 #include <vtkAssemblyPath.h>
 #include <vtkAssemblyNode.h>
 #include <vtkMapper.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 #include <vtkInteractorStyleTrackballCamera.h>
 
 mitk::VtkPropRenderer::VtkPropRenderer( const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm, mitk::BaseRenderer::RenderingMode::Type renderingMode )
   : BaseRenderer(name,renWin, rm, renderingMode ),
   m_VtkMapperPresent(false),
   m_CameraInitializedForMapperID(0)
 {
   didCount=false;
 
   m_WorldPointPicker = vtkWorldPointPicker::New();
 
   m_PointPicker = vtkPointPicker::New();
   m_PointPicker->SetTolerance( 0.0025 );
 
   m_CellPicker = vtkCellPicker::New();
   m_CellPicker->SetTolerance( 0.0025 );
 
-  mitk::Geometry2DDataVtkMapper3D::Pointer geometryMapper = mitk::Geometry2DDataVtkMapper3D::New();
-  m_CurrentWorldGeometry2DMapper = geometryMapper;
-  m_CurrentWorldGeometry2DNode->SetMapper(2, geometryMapper);
+  mitk::PlaneGeometryDataVtkMapper3D::Pointer geometryMapper = mitk::PlaneGeometryDataVtkMapper3D::New();
+  m_CurrentWorldPlaneGeometryMapper = geometryMapper;
+  m_CurrentWorldPlaneGeometryNode->SetMapper(2, geometryMapper);
 
   m_LightKit = vtkLightKit::New();
   m_LightKit->AddLightsToRenderer(m_VtkRenderer);
   m_PickingMode = WorldPointPicking;
 
   m_TextRenderer = vtkRenderer::New();
   m_TextRenderer->SetRenderWindow(renWin);
   m_TextRenderer->SetInteractive(0);
   m_TextRenderer->SetErase(0);
 }
 
 /*!
 \brief Destructs the VtkPropRenderer.
 */
 mitk::VtkPropRenderer::~VtkPropRenderer()
 {
   // Workaround for GLDisplayList Bug
   {
     m_MapperID=0;
     checkState();
   }
 
   if (m_LightKit != NULL)
     m_LightKit->Delete();
 
   if (m_VtkRenderer!=NULL)
   {
     m_CameraController = NULL;
 
     m_VtkRenderer->Delete();
 
     m_VtkRenderer = NULL;
   }
   else
     m_CameraController = NULL;
 
   if (m_WorldPointPicker != NULL)
     m_WorldPointPicker->Delete();
   if (m_PointPicker != NULL)
     m_PointPicker->Delete();
   if (m_CellPicker != NULL)
     m_CellPicker->Delete();
   if (m_TextRenderer != NULL)
     m_TextRenderer->Delete();
 }
 
 void mitk::VtkPropRenderer::SetDataStorage(  mitk::DataStorage* storage  )
 {
   if ( storage == NULL )
     return;
 
   BaseRenderer::SetDataStorage(storage);
 
-  static_cast<mitk::Geometry2DDataVtkMapper3D*>(m_CurrentWorldGeometry2DMapper.GetPointer())->SetDataStorageForTexture( m_DataStorage.GetPointer() );
+  static_cast<mitk::PlaneGeometryDataVtkMapper3D*>(m_CurrentWorldPlaneGeometryMapper.GetPointer())->SetDataStorageForTexture( m_DataStorage.GetPointer() );
 
   // Compute the geometry from the current data tree bounds and set it as world geometry
   this->SetWorldGeometryToDataStorageBounds();
 }
 
 bool mitk::VtkPropRenderer::SetWorldGeometryToDataStorageBounds()
 {
   if ( m_DataStorage.IsNull() )
     return false;
 
   //initialize world geometry
   mitk::TimeGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D( NULL, "includeInBoundingBox" );
 
   if ( geometry.IsNull() )
     return false;
 
   this->SetWorldTimeGeometry(geometry);
   //this->GetDisplayGeometry()->SetSizeInDisplayUnits( this->m_TextRenderer->GetRenderWindow()->GetSize()[0], this->m_TextRenderer->GetRenderWindow()->GetSize()[1] );
   this->GetDisplayGeometry()->Fit();
   this->GetVtkRenderer()->ResetCamera();
   this->Modified();
   return true;
 }
 
 /*!
 \brief
 
 Called by the vtkMitkRenderProp in order to start MITK rendering process.
 */
 int mitk::VtkPropRenderer::Render(mitk::VtkPropRenderer::RenderType type)
 {
   // Do we have objects to render?
   if ( this->GetEmptyWorldGeometry())
     return 0;
 
   if ( m_DataStorage.IsNull())
     return 0;
 
   // Update mappers and prepare mapper queue
   if (type == VtkPropRenderer::Opaque)
     this->PrepareMapperQueue();
 
   //go through the generated list and let the sorted mappers paint
   bool lastVtkBased = true;
   //bool sthVtkBased = false;
 
   for(MappersMapType::iterator it = m_MappersMap.begin(); it != m_MappersMap.end(); it++)
   {
     Mapper * mapper = (*it).second;
 
     VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>(mapper);
 
     if(vtkmapper)
     {
       //sthVtkBased = true;
       if(!lastVtkBased)
       {
         Disable2DOpenGL();
         lastVtkBased = true;
       }
     }
     else if(lastVtkBased)
     {
       Enable2DOpenGL();
       lastVtkBased = false;
     }
 
     mapper->MitkRender(this, type);
   }
 
   this->UpdateOverlays();
 
   if (lastVtkBased == false)
     Disable2DOpenGL();
 
   // Render text
   if (type == VtkPropRenderer::Overlay)
   {
     if (m_TextCollection.size() > 0)
     {
       m_TextRenderer->SetViewport( this->GetVtkRenderer()->GetViewport() );
       for (TextMapType::iterator it = m_TextCollection.begin(); it != m_TextCollection.end() ; it++)
         m_TextRenderer->AddViewProp((*it).second);
       m_TextRenderer->Render();
     }
   }
   return 1;
 }
 
 /*!
 \brief PrepareMapperQueue iterates the datatree
 
 PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers wrt to their layer.
 */
 void mitk::VtkPropRenderer::PrepareMapperQueue()
 {
   // variable for counting LOD-enabled mappers
   m_NumberOfVisibleLODEnabledMappers = 0;
 
   // Do we have to update the mappers ?
   if ( m_LastUpdateTime < GetMTime() || m_LastUpdateTime < GetDisplayGeometry()->GetMTime() ) {
     Update();
   }
   else if (m_MapperID>=1 && m_MapperID < 6)
     Update();
 
   // remove all text properties before mappers will add new ones
   m_TextRenderer->RemoveAllViewProps();
 
   for ( unsigned int i=0; i<m_TextCollection.size(); i++ )
   {
     m_TextCollection[i]->Delete();
   }
   m_TextCollection.clear();
 
   // clear priority_queue
   m_MappersMap.clear();
 
   int mapperNo = 0;
 
   //DataStorage
   if( m_DataStorage.IsNull() )
     return;
 
   DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
 
   for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();  it != allObjects->End(); ++it)
   {
     DataNode::Pointer node = it->Value();
     if ( node.IsNull() )
       continue;
     mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
 
     if ( mapper.IsNull() )
       continue;
 
     bool visible = true;
     node->GetVisibility(visible, this, "visible");
 
     // The information about LOD-enabled mappers is required by RenderingManager
     if ( mapper->IsLODEnabled( this ) && visible )
     {
       ++m_NumberOfVisibleLODEnabledMappers;
     }
     // mapper without a layer property get layer number 1
     int layer = 1;
     node->GetIntProperty("layer", layer, this);
     int nr = (layer<<16) + mapperNo;
     m_MappersMap.insert( std::pair< int, Mapper * >( nr, mapper ) );
     mapperNo++;
   }
 }
 
 /*!
 \brief
 
 Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
 */
 void mitk::VtkPropRenderer::Enable2DOpenGL()
 {
   GLint iViewport[4];
 
   // Get a copy of the viewport
   glGetIntegerv( GL_VIEWPORT, iViewport );
 
   // Save a copy of the projection matrix so that we can restore it
   // when it's time to do 3D rendering again.
   glMatrixMode( GL_PROJECTION );
   glPushMatrix();
   glLoadIdentity();
 
   // Set up the orthographic projection
   const DisplayGeometry* displayGeometry = this->GetDisplayGeometry();
 
   float displayGeometryWidth = displayGeometry->GetSizeInDisplayUnits()[0];
   float displayGeometryHeight = displayGeometry->GetSizeInDisplayUnits()[1];
   float viewportWidth = iViewport[2];
   float viewportHeight = iViewport[3];
 
   /*
      The following makes OpenGL mappers draw into the same viewport
      that is used by VTK when someone calls vtkRenderer::SetViewport().
 
      The parameters of glOrtho describe what "input" coordinates
      (display coordinates generated by the OpenGL mappers) are transformed
      into the region defined by the viewport. The call has to consider
      that the scene is fit vertically and centered horizontally.
 
      Problem: this is a crude first step towards rendering into viewports.
       - mitkViewportRenderingTest demonstrates the non-interactive rendering
         that is now possible
       - interactors that measure mouse movement in pixels will
         probably run into problems with display-to-world transformation
 
      A proper solution should probably modify the DisplayGeometry to
      correctly describe the viewport.
   */
   // iViewport is (x,y,width,height)
   // glOrtho expects (left,right,bottom,top,znear,zfar)
   glOrtho( 0
            - 0.5 * (viewportWidth/viewportHeight-1.0)*displayGeometryHeight
            + 0.5 * (displayGeometryWidth - displayGeometryHeight)
            ,
            displayGeometryWidth
            + 0.5 * (viewportWidth/viewportHeight-1.0)*displayGeometryHeight
            - 0.5 * (displayGeometryWidth - displayGeometryHeight)
            ,
            0, displayGeometryHeight,
       -1.0, 1.0
       );
 
   glMatrixMode( GL_MODELVIEW );
   glPushMatrix();
   glLoadIdentity();
 
   // Make sure depth testing and lighting are disabled for 2D rendering until
   // we are finished rendering in 2D
   glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT );
   glDisable( GL_DEPTH_TEST );
   glDisable( GL_LIGHTING );
   // disable the texturing here so crosshair is painted in the correct colors
   // vtk will reenable texturing every time it is needed
   glDisable( GL_TEXTURE_1D );
   glDisable( GL_TEXTURE_2D );
   glLineWidth(1.0);
 }
 
 /*!
 \brief Initialize the VtkPropRenderer
 
 Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
 */
 void mitk::VtkPropRenderer::Disable2DOpenGL()
 {
   glPopAttrib();
   glMatrixMode( GL_PROJECTION );
   glPopMatrix();
   glMatrixMode( GL_MODELVIEW );
   glPopMatrix();
 }
 
 void mitk::VtkPropRenderer::Update(mitk::DataNode* datatreenode)
 {
   if(datatreenode!=NULL)
   {
     mitk::Mapper::Pointer mapper = datatreenode->GetMapper(m_MapperID);
     if(mapper.IsNotNull())
     {
       GLMapper* glmapper=dynamic_cast<GLMapper*>(mapper.GetPointer());
 
       if(GetDisplayGeometry()->IsValid())
       {
         if(glmapper != NULL)
         {
           glmapper->Update(this);
           m_VtkMapperPresent=false;
         }
         else
         {
           VtkMapper* vtkmapper=dynamic_cast<VtkMapper*>(mapper.GetPointer());
           if(vtkmapper != NULL)
           {
             vtkmapper->Update(this);
             vtkmapper->UpdateVtkTransform(this);
             m_VtkMapperPresent=true;
           }
         }
       }
     }
   }
 }
 
 void mitk::VtkPropRenderer::Update()
 {
   if( m_DataStorage.IsNull() )
     return;
 
   m_VtkMapperPresent = false;
   mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
     Update(it->Value());
 
   Modified();
   m_LastUpdateTime = GetMTime();
 }
 
 /*!
 \brief
 
 This method is called from the two Constructors
 */
 void mitk::VtkPropRenderer::InitRenderer(vtkRenderWindow* renderWindow)
 {
   BaseRenderer::InitRenderer(renderWindow);
 
   if(renderWindow == NULL)
   {
     m_InitNeeded = false;
     m_ResizeNeeded = false;
     return;
   }
 
   m_InitNeeded = true;
   m_ResizeNeeded = true;
 
   m_LastUpdateTime = 0;
 }
 
 /*!
 \brief Resize the OpenGL Window
 */
 void mitk::VtkPropRenderer::Resize(int w, int h)
 {
   BaseRenderer::Resize(w, h);
   m_RenderingManager->RequestUpdate(this->GetRenderWindow());
 }
 
 void mitk::VtkPropRenderer::InitSize(int w, int h)
 {
   m_RenderWindow->SetSize(w,h);
   Superclass::InitSize(w, h);
   Modified();
   Update();
   if(m_VtkRenderer!=NULL)
   {
     int w=vtkObject::GetGlobalWarningDisplay();
     vtkObject::GlobalWarningDisplayOff();
     m_VtkRenderer->ResetCamera();
     vtkObject::SetGlobalWarningDisplay(w);
   }
 }
 
 void mitk::VtkPropRenderer::SetMapperID(const MapperSlotId mapperId)
 {
   if(m_MapperID != mapperId)
     Superclass::SetMapperID(mapperId);
 
   // Workaround for GL Displaylist Bug
   checkState();
 }
 
 /*!
 \brief Activates the current renderwindow.
 */
 void mitk::VtkPropRenderer::MakeCurrent()
 {
   if(m_RenderWindow!=NULL)
     m_RenderWindow->MakeCurrent();
 }
 
 void mitk::VtkPropRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
 {
   if(m_VtkMapperPresent)
   {
     //m_WorldPointPicker->SetTolerance (0.0001);
     switch ( m_PickingMode )
     {
     case (WorldPointPicking) :
       {
         m_WorldPointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
         vtk2itk(m_WorldPointPicker->GetPickPosition(), worldPoint);
         break;
       }
     case (PointPicking) :
       {
         // create a new vtkRenderer
         // give it all necessary information (camera position, etc.)
         // get all surfaces from datastorage, get actors from them
         // add all those actors to the new renderer
         // give this new renderer to pointpicker
         /*
        vtkRenderer* pickingRenderer = vtkRenderer::New();
        pickingRenderer->SetActiveCamera( );
 
        DataStorage* dataStorage = m_DataStorage;
        TNodePredicateDataType<Surface> isSurface;
 
        DataStorage::SetOfObjects::ConstPointer allSurfaces = dataStorage->GetSubset( isSurface );
        MITK_INFO << "in picking: got " << allSurfaces->size() << " surfaces." << std::endl;
 
        for (DataStorage::SetOfObjects::const_iterator iter = allSurfaces->begin();
             iter != allSurfaces->end();
             ++iter)
        {
          const DataNode* currentNode = *iter;
          VtkMapper3D* baseVtkMapper3D = dynamic_cast<VtkMapper3D*>( currentNode->GetMapper( BaseRenderer::Standard3D ) );
          if ( baseVtkMapper3D )
          {
            vtkActor* actor = dynamic_cast<vtkActor*>( baseVtkMapper3D->GetViewProp() );
            if (actor)
            {
              MITK_INFO << "a" << std::flush;
              pickingRenderer->AddActor( actor );
            }
          }
        }
 
        MITK_INFO << ";" << std::endl;
        */
         m_PointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
         vtk2itk(m_PointPicker->GetPickPosition(), worldPoint);
         break;
       }
     case(CellPicking) :
       {
         m_CellPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
         vtk2itk(m_CellPicker->GetPickPosition(), worldPoint);
         break;
       }
     }
   }
   else
   {
     Superclass::PickWorldPoint(displayPoint, worldPoint);
   }
 }
 
 mitk::DataNode *
     mitk::VtkPropRenderer::PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const
 {
   if ( m_VtkMapperPresent )
   {
     m_CellPicker->InitializePickList();
 
     // Iterate over all DataStorage objects to determine all vtkProps intended
     // for picking
     DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
     for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
     it != allObjects->End();
     ++it )
     {
       DataNode *node = it->Value();
       if ( node == NULL )
         continue;
 
       bool pickable = false;
       node->GetBoolProperty( "pickable", pickable );
       if ( !pickable )
         continue;
 
       VtkMapper *mapper = dynamic_cast < VtkMapper * >  ( node->GetMapper( m_MapperID ) );
       if ( mapper == NULL )
         continue;
 
       vtkProp *prop = mapper->GetVtkProp( (mitk::BaseRenderer *)this );
       if ( prop == NULL )
         continue;
 
       m_CellPicker->AddPickList( prop );
     }
 
     // Do the picking and retrieve the picked vtkProp (if any)
     m_CellPicker->PickFromListOn();
     m_CellPicker->Pick( displayPosition[0], displayPosition[1], 0.0, m_VtkRenderer );
     m_CellPicker->PickFromListOff();
 
     vtk2itk( m_CellPicker->GetPickPosition(), worldPosition );
     vtkProp *prop = m_CellPicker->GetViewProp();
 
     if ( prop == NULL )
     {
       return NULL;
     }
 
     // Iterate over all DataStorage objects to determine if the retrieved
     // vtkProp is owned by any associated mapper.
     for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
     it != allObjects->End();
     ++it)
     {
       DataNode::Pointer node = it->Value();
       if ( node.IsNull() )
         continue;
 
       mitk::Mapper * mapper = node->GetMapper( m_MapperID );
       if ( mapper == NULL)
         continue;
 
       mitk::VtkMapper * vtkmapper = dynamic_cast< VtkMapper * >(mapper);
 
       if(vtkmapper){
         //if vtk-based, then ...
        if ( vtkmapper->HasVtkProp( prop, const_cast< mitk::VtkPropRenderer * >( this ) ) )
        {
           return node;
        }
       }
     }
 
     return NULL;
   }
   else
   {
     return Superclass::PickObject( displayPosition, worldPosition );
   }
 };
 
 /*!
 \brief Writes some 2D text as overlay. Function returns an unique int Text_ID for each call, which can be used via the GetTextLabelProperty(int text_id) function
 in order to get a vtkTextProperty. This property enables the setup of font, font size, etc.
 */
 int mitk::VtkPropRenderer::WriteSimpleText(std::string text, double posX, double posY, double color1, double color2, double color3, float opacity)
 {
   if(!text.empty())
   {
     Point2D p;
     p[0] = posX;
     p[1] = posY;
     p = TransformOpenGLPointToViewport(p);
 
     vtkTextActor* textActor = vtkTextActor::New();
 
     textActor->SetPosition(p[0], p[1]);
     textActor->SetInput(text.c_str());
     textActor->SetTextScaleModeToNone();
     textActor->GetTextProperty()->SetColor(color1, color2, color3); //TODO: Read color from node property
     textActor->GetTextProperty()->SetOpacity( opacity );
     int text_id = m_TextCollection.size();
     m_TextCollection.insert(TextMapType::value_type(text_id,textActor));
     return text_id;
   }
   else
   {
     return -1;
   }
 }
 
 /*!
 \brief Can be used in order to get a vtkTextProperty for a specific text_id. This property enables the setup of font, font size, etc.
 */
 vtkTextProperty* mitk::VtkPropRenderer::GetTextLabelProperty(int text_id)
 {
   return this->m_TextCollection[text_id]->GetTextProperty();
 }
 
 void mitk::VtkPropRenderer::InitPathTraversal()
 {
   if (m_DataStorage.IsNotNull())
   {
     m_PickingObjects = m_DataStorage->GetAll();
     m_PickingObjectsIterator = m_PickingObjects->begin();
   }
 }
 
 vtkAssemblyPath* mitk::VtkPropRenderer::GetNextPath()
 {
   if (m_DataStorage.IsNull() )
   {
     return NULL;
   }
 
   if ( m_PickingObjectsIterator == m_PickingObjects->end() )
   {
     return NULL;
   }
 
   vtkAssemblyPath* returnPath = vtkAssemblyPath::New();
   //returnPath->Register(NULL);
 
   bool success = false;
 
   while (!success)
   {
     // loop until AddNode can be called successfully
     const DataNode* node = *m_PickingObjectsIterator;
     if (node)
     {
       Mapper* mapper = node->GetMapper( BaseRenderer::Standard3D );
       if (mapper)
       {
         VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>( mapper );
         if (vtkmapper)
         {
           vtkProp* prop = vtkmapper->GetVtkProp(this);
           if ( prop && prop->GetVisibility() )
           {
             // add to assembly path
             returnPath->AddNode( prop, prop->GetMatrix() );
             success = true;
           }
         }
       }
     }
 
     ++m_PickingObjectsIterator;
 
     if ( m_PickingObjectsIterator == m_PickingObjects->end() ) break;
   }
 
   if ( success )
   {
     return returnPath;
   }
   else
   {
     return NULL;
   }
 }
 
 void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow* /*renWin*/)
 {
   if( m_DataStorage.IsNull() )
     return;
 
   DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
   for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter)
   {
     DataNode::Pointer node = *iter;
     if ( node.IsNull() )
       continue;
 
       Mapper * mapper = node->GetMapper(m_MapperID);
 
       if (mapper)
       {
         VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>( mapper );
 
        if(vtkmapper)
          vtkmapper->ReleaseGraphicsResources(this);
       }
    }
 }
 
 const vtkWorldPointPicker *mitk::VtkPropRenderer::GetWorldPointPicker() const
 {
   return m_WorldPointPicker;
 }
 
 const vtkPointPicker *mitk::VtkPropRenderer::GetPointPicker() const
 {
   return m_PointPicker;
 }
 
 const vtkCellPicker *mitk::VtkPropRenderer::GetCellPicker() const
 {
   return m_CellPicker;
 }
 
 mitk::VtkPropRenderer::MappersMapType mitk::VtkPropRenderer::GetMappersMap() const
 {
   return m_MappersMap;
 }
 
 // Workaround for GL Displaylist bug
 
 static int glWorkAroundGlobalCount = 0;
 
 bool mitk::VtkPropRenderer::useImmediateModeRendering()
 {
   return glWorkAroundGlobalCount>1;
 }
 
 void mitk::VtkPropRenderer::checkState()
 {
   if (m_MapperID == Standard3D)
   {
     if (!didCount)
     {
       didCount = true;
       glWorkAroundGlobalCount++;
 
       if (glWorkAroundGlobalCount == 2)
       {
         MITK_INFO << "Multiple 3D Renderwindows active...: turning Immediate Rendering ON for legacy mappers";
         //          vtkMapper::GlobalImmediateModeRenderingOn();
       }
       //MITK_INFO << "GLOBAL 3D INCREASE " << glWorkAroundGlobalCount << "\n";
     }
   }
   else
   {
     if(didCount)
     {
       didCount=false;
       glWorkAroundGlobalCount--;
       if(glWorkAroundGlobalCount==1)
       {
         MITK_INFO << "Single 3D Renderwindow active...: turning Immediate Rendering OFF for legacy mappers";
         //        vtkMapper::GlobalImmediateModeRenderingOff();
       }
       //MITK_INFO << "GLOBAL 3D DECREASE " << glWorkAroundGlobalCount << "\n";
     }
   }
 }
 
 //### Contains all methods which are neceassry before each VTK Render() call
 void mitk::VtkPropRenderer::PrepareRender()
 {
   if ( this->GetMapperID() != m_CameraInitializedForMapperID )
   {
     Initialize2DvtkCamera(); //Set parallel projection etc.
   }
 
   AdjustCameraToScene(); //Prepare camera for 2D render windows
 }
 
 bool mitk::VtkPropRenderer::Initialize2DvtkCamera()
 {
   if ( this->GetMapperID() == Standard3D )
   {
     //activate parallel projection for 2D
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(false);
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( vtkInteractorStyleTrackballCamera::New() );
     m_CameraInitializedForMapperID = Standard3D;
   }
   else if( this->GetMapperID() == Standard2D)
   {
     //activate parallel projection for 2D
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true);
     //turn the light out in the scene in order to render correct grey values.
     //TODO Implement a property for light in the 2D render windows (in another method)
     this->GetVtkRenderer()->RemoveAllLights();
 
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( mitkVtkInteractorStyle::New() );
 
     m_CameraInitializedForMapperID = Standard2D;
   }
   return true;
 }
 
 void mitk::VtkPropRenderer::AdjustCameraToScene(){
   if(this->GetMapperID() == Standard2D)
   {
     const mitk::DisplayGeometry* displayGeometry = this->GetDisplayGeometry();
 
-    double objectHeightInMM = this->GetCurrentWorldGeometry2D()->GetExtentInMM(1);//the height of the current object slice in mm
+    double objectHeightInMM = this->GetCurrentWorldPlaneGeometry()->GetExtentInMM(1);//the height of the current object slice in mm
     double displayHeightInMM = displayGeometry->GetSizeInMM()[1]; //the display height in mm (gets smaller when you zoom in)
     double zoomFactor = objectHeightInMM/displayHeightInMM; //displayGeometry->GetScaleFactorMMPerDisplayUnit()
     //determine how much of the object can be displayed
 
     Vector2D displayGeometryOriginInMM = displayGeometry->GetOriginInMM();  //top left of the render window (Origin)
     Vector2D displayGeometryCenterInMM = displayGeometryOriginInMM + displayGeometry->GetSizeInMM()*0.5; //center of the render window: (Origin + Size/2)
 
     //Scale the rendered object:
     //The image is scaled by a single factor, because in an orthographic projection sizes
     //are preserved (so you cannot scale X and Y axis with different parameters). The
     //parameter sets the size of the total display-volume. If you set this to the image
     //height, the image plus a border with the size of the image will be rendered.
     //Therefore, the size is imageHeightInMM / 2.
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(objectHeightInMM*0.5 );
     //zooming with the factor calculated by dividing displayHeight through imegeHeight. The factor is inverse, because the VTK zoom method is working inversely.
     this->GetVtkRenderer()->GetActiveCamera()->Zoom(zoomFactor);
 
     //the center of the view-plane
     double viewPlaneCenter[3];
     viewPlaneCenter[0] = displayGeometryCenterInMM[0];
     viewPlaneCenter[1] = displayGeometryCenterInMM[1];
     viewPlaneCenter[2] = 0.0; //the view-plane is located in the XY-plane with Z=0.0
 
     //define which direction is "up" for the ciamera (like default for vtk (0.0, 1.0, 0.0)
     double cameraUp[3];
     cameraUp[0] = 0.0;
     cameraUp[1] = 1.0;
     cameraUp[2] = 0.0;
 
     //the position of the camera (center[0], center[1], 900000)
     double cameraPosition[3];
     cameraPosition[0] = viewPlaneCenter[0];
     cameraPosition[1] = viewPlaneCenter[1];
     cameraPosition[2] = 900000.0; //Reason for 900000: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
 
     //set the camera corresponding to the textured plane
     vtkSmartPointer<vtkCamera> camera = this->GetVtkRenderer()->GetActiveCamera();
     if (camera)
     {
       camera->SetPosition( cameraPosition ); //set the camera position on the textured plane normal (in our case this is the view plane normal)
       camera->SetFocalPoint( viewPlaneCenter ); //set the focal point to the center of the textured plane
       camera->SetViewUp( cameraUp ); //set the view-up for the camera
       //      double distance = sqrt((cameraPosition[2]-viewPlaneCenter[2])*(cameraPosition[2]-viewPlaneCenter[2]));
       //      camera->SetClippingRange(distance-50, distance+50); //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
       camera->SetClippingRange(0.1, 1000000); //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
     }
 
-    const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( this->GetCurrentWorldGeometry2D() );
+    const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( this->GetCurrentWorldPlaneGeometry() );
     if ( planeGeometry != NULL )
     {
       //Transform the camera to the current position (transveral, coronal and saggital plane).
       //This is necessary, because the SetUserTransform() method does not manipulate the vtkCamera.
       //(Without not all three planes would be visible).
       vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
       vtkSmartPointer<vtkMatrix4x4> matrix = vtkSmartPointer<vtkMatrix4x4>::New();
       Point3D origin;
       Vector3D right, bottom, normal;
 
       origin = planeGeometry->GetOrigin();
       right  = planeGeometry->GetAxisVector( 0 ); // right = Extent of Image in mm (worldspace)
       bottom = planeGeometry->GetAxisVector( 1 );
       normal = planeGeometry->GetNormal();
 
       right.Normalize();
       bottom.Normalize();
       normal.Normalize();
 
       matrix->SetElement(0, 0, right[0]);
       matrix->SetElement(1, 0, right[1]);
       matrix->SetElement(2, 0, right[2]);
       matrix->SetElement(0, 1, bottom[0]);
       matrix->SetElement(1, 1, bottom[1]);
       matrix->SetElement(2, 1, bottom[2]);
       matrix->SetElement(0, 2, normal[0]);
       matrix->SetElement(1, 2, normal[1]);
       matrix->SetElement(2, 2, normal[2]);
       matrix->SetElement(0, 3, origin[0]);
       matrix->SetElement(1, 3, origin[1]);
       matrix->SetElement(2, 3, origin[2]);
       matrix->SetElement(3, 0, 0.0);
       matrix->SetElement(3, 1, 0.0);
       matrix->SetElement(3, 2, 0.0);
       matrix->SetElement(3, 3, 1.0);
 
       trans->SetMatrix(matrix);
       //Transform the camera to the current position (transveral, coronal and saggital plane).
       this->GetVtkRenderer()->GetActiveCamera()->ApplyTransform(trans);
     }
   }
 }
 
 mitk::Point2D mitk::VtkPropRenderer::TransformOpenGLPointToViewport( mitk::Point2D point )
 {
   GLint iViewport[4];
   // Get a copy of the viewport
   glGetIntegerv( GL_VIEWPORT, iViewport );
   const mitk::DisplayGeometry* displayGeometry = this->GetDisplayGeometry();
 
   float displayGeometryWidth = displayGeometry->GetSizeInDisplayUnits()[0];
   float displayGeometryHeight = displayGeometry->GetSizeInDisplayUnits()[1];
 
   float viewportWidth = iViewport[2];
   float viewportHeight = iViewport[3]; // seemingly right
 
   float zoom = viewportHeight / displayGeometryHeight;
 
   // see glOrtho call above for more explanation
   point[0] +=
     0.5 * (viewportWidth/viewportHeight-1.0)*displayGeometryHeight
     - 0.5 * (displayGeometryWidth - displayGeometryHeight)
     ;
 
   point[0] *= zoom;
   point[1] *= zoom;
 
   return point;
 }
\ No newline at end of file
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.h b/Core/Code/Rendering/mitkVtkPropRenderer.h
index 09d11a3bd3..31024e0f8c 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.h
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.h
@@ -1,256 +1,256 @@
 /*===================================================================
 
 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 MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D
 #define MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D
 
 #include <MitkCoreExports.h>
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
 
 #include <itkCommand.h>
 
 #include <map>
 #include <utility>
 
 class vtkRenderWindow;
 class vtkLight;
 class vtkLightKit;
 class vtkWorldPointPicker;
 class vtkPointPicker;
 class vtkCellPicker;
 class vtkTextActor;
 class vtkTextProperty;
 class vtkAssemblyPath;
 
 namespace mitk
 {
 class Mapper;
 
 /*!
 \brief VtkPropRenderer
 
 VtkPropRenderer organizes the MITK rendering process. The MITK rendering process is completely integrated into the VTK rendering pipeline.
 The vtkMitkRenderProp is a custom vtkProp derived class, which implements the rendering interface between MITK and VTK. It redirects render() calls to the VtkPropRenderer, which is responsible for rendering of the datatreenodes.
 VtkPropRenderer replaces the old OpenGLRenderer.
 
 \sa rendering
 \ingroup rendering
 */
 class MITK_CORE_EXPORT VtkPropRenderer : public BaseRenderer
 {
   // Workaround for Displaylistbug
 private:
   bool didCount;
   void checkState();
 
   // Workaround END
 
 public:
 
   mitkClassMacro(VtkPropRenderer,BaseRenderer);
   mitkNewMacro3Param(VtkPropRenderer, const char*, vtkRenderWindow *, mitk::RenderingManager* );
   mitkNewMacro4Param(VtkPropRenderer, const char*, vtkRenderWindow *, mitk::RenderingManager*, mitk::BaseRenderer::RenderingMode::Type );
 
   typedef std::map<int,Mapper*> MappersMapType;
 
   // Render - called by vtkMitkRenderProp, returns the number of props rendered
   enum RenderType{Opaque,Translucent,Overlay,Volumetric};
 
   int Render(RenderType type);
 
   /** \brief This methods contains all method neceassary before a VTK Render() call */
   virtual void PrepareRender();
 
   // Active current renderwindow
   virtual void MakeCurrent();
 
   virtual void SetDataStorage( mitk::DataStorage* storage );  ///< set the datastorage that will be used for rendering
 
   virtual void InitRenderer(vtkRenderWindow* renderwindow);
   virtual void Update(mitk::DataNode* datatreenode);
   virtual void SetMapperID(const MapperSlotId mapperId);
 
   // Size
   virtual void InitSize(int w, int h);
   virtual void Resize(int w, int h);
 
   // Picking
   enum PickingMode{ WorldPointPicking, PointPicking, CellPicking};
   /** \brief  Set the picking mode.
   This method is used to set the picking mode for 3D object picking. The user can select one of
   the three options WorldPointPicking, PointPicking and CellPicking. The first option uses the zBuffer
   from graphics rendering, the second uses the 3D points from the closest surface mesh, and the third
   option uses the cells   of that mesh. The last option is the slowest, the first one the fastest.
   However, the first option cannot use transparent data object and the tolerance of the picked position
   to the selected point should be considered. PointPicking also need a tolerance around the picking
   position to select the closest point in the mesh. The CellPicker performs very well, if the
   foreground surface part (i.e. the surfacepart that is closest to the scene's cameras) needs to be
   picked. */
   itkSetEnumMacro( PickingMode, PickingMode );
   itkGetEnumMacro( PickingMode, PickingMode );
 
   virtual void PickWorldPoint(const Point2D& displayPoint, Point3D& worldPoint) const;
   virtual mitk::DataNode *PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const;
 
   // Simple text rendering method
   int WriteSimpleText(std::string text, double posX, double posY, double color1 = 0.0, double color2 = 1.0, double color3 = 0.0, float opacity = 1.0);
 
   vtkTextProperty * GetTextLabelProperty(int text_id);
 
   // Initialization / geometry handling
 
   /** This method calculates the bounds of the DataStorage (if it contains any
    * valid data), creates a geometry from these bounds and sets it as world
    * geometry of the renderer.
    *
    * Call this method to re-initialize the renderer to the current DataStorage
    * (e.g. after loading an additional dataset), to ensure that the view is
    * aligned correctly.
    */
   virtual bool SetWorldGeometryToDataStorageBounds();
 
   /**
    * \brief Used by vtkPointPicker/vtkPicker.
    * This will query a list of all objects in MITK and provide every vtk based mapper to the picker.
    */
   void InitPathTraversal();
 
   /**
    * \brief Used by vtkPointPicker/vtkPicker.
    * This will query a list of all objects in MITK and provide every vtk based mapper to the picker.
    */
   vtkAssemblyPath* GetNextPath();
 
   const vtkWorldPointPicker *GetWorldPointPicker() const;
   const vtkPointPicker *GetPointPicker() const;
   const vtkCellPicker *GetCellPicker() const;
 
   /**
   * \brief Release vtk-based graphics resources. Called by
   * vtkMitkRenderProp::ReleaseGraphicsResources.
   */
   virtual void ReleaseGraphicsResources(vtkWindow *renWin);
 
   MappersMapType GetMappersMap() const;
 
   static bool useImmediateModeRendering();
 
 protected:
   VtkPropRenderer( const char* name = "VtkPropRenderer", vtkRenderWindow * renWin = NULL, mitk::RenderingManager* rm = NULL, mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard );
   virtual ~VtkPropRenderer();
   virtual void Update();
 
   /**
     \brief Convert display geometry coordinates to VTK coordinates.
 
     For use within WriteSimpleText: the input is display geometry coordinates
     but the text actor needs positions that fit in a specified viewport.
     Conversion is done in this method.
   */
   mitk::Point2D TransformOpenGLPointToViewport( mitk::Point2D point );
 
 private:
 
   /** \brief This method sets up the camera on the actor (e.g. an image) of all
   * 2D vtkRenderWindows. The view is centered; zooming and panning of VTK are called inside.
   *
   * \image html ImageMapperdisplayGeometry.png
   *
   * Similar to the textured plane of an image
   * (cf. void mitkImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer* renderer,
   * double planeBounds[6])), the mitkDisplayGeometry defines a view plane (or
   * projection plane). This plane is used to set the camera parameters. The view plane
   * center (VC) is important for camera positioning (cf. the image above).
   *
   * The following figure shows the combination of the textured plane and the view plane.
   *
   * \image html cameraPositioning.png
   *
   * The view plane center (VC) is the center of the textured plane (C) and the focal point
   * (FP) at the same time. The FP defines the direction the camera faces. Since
   * the textured plane is always in the XY-plane and orthographic projection is applied, the
   * distance between camera and plane is theoretically irrelevant (because in the orthographic
   * projection the center of projection is at infinity and the size of objects depends only on
   * a scaling parameter). As a consequence, the direction of projection (DOP) is (0; 0; -1).
   * The camera up vector is always defined as (0; 1; 0).
   *
   * \warning Due to a VTK clipping bug the distance between textured plane and camera is really huge.
   * Otherwise, VTK would clip off some slices. Same applies for the clipping range size.
   *
   * \note The camera position is defined through the mitkDisplayGeometry.
   * This facilitates zooming and panning, because the display
   * geometry changes and the textured plane does not.
   *
   * \image html scaling.png
   *
   * The textured plane is scaled to fill the render window via
   * camera->SetParallelScale( imageHeightInMM / 2). In the orthographic projection all extends,
   * angles and sizes are preserved. Therefore, the image is scaled by one parameter which defines
   * the size of the rendered image. A higher value will result in smaller images. In order to render
   * just the whole image, the scale is set to half of the image height in worldcoordinates
   * (cf. the picture above).
   *
   * For zooming purposes, a factor is computed as follows:
   * factor = image height / display height (in worldcoordinates).
   * When the display geometry gets smaller (zoom in), the factor becomes bigger. When the display
   * geometry gets bigger (zoom out), the factor becomes smaller. The used VTK method
   * camera->Zoom( factor ) also works with an inverse scale.
   */
   void AdjustCameraToScene();
 
   // switch between orthogonal opengl projection (2D rendering via mitk::GLMapper2D) and perspective projection (3D rendering)
   void Enable2DOpenGL();
   void Disable2DOpenGL();
 
   // prepare all mitk::mappers for rendering
   void PrepareMapperQueue();
 
   /** \brief Set parallel projection, remove the interactor and the lights of VTK. */
   bool Initialize2DvtkCamera();
 
   bool m_InitNeeded;
   bool m_ResizeNeeded;
   bool m_VtkMapperPresent;
   MapperSlotId m_CameraInitializedForMapperID;
 
   // Picking
   vtkWorldPointPicker     * m_WorldPointPicker;
   vtkPointPicker          * m_PointPicker;
   vtkCellPicker           * m_CellPicker;
 
   PickingMode               m_PickingMode;
 
   // Explicit use of SmartPointer to avoid circular #includes
-  itk::SmartPointer< mitk::Mapper > m_CurrentWorldGeometry2DMapper;
+  itk::SmartPointer< mitk::Mapper > m_CurrentWorldPlaneGeometryMapper;
 
   vtkLightKit* m_LightKit;
 
   // sorted list of mappers
   MappersMapType m_MappersMap;
 
   // rendering of text
   vtkRenderer * m_TextRenderer;
   typedef std::map<unsigned int,vtkTextActor*> TextMapType;
   TextMapType m_TextCollection;
 
   DataStorage::SetOfObjects::ConstPointer m_PickingObjects;
   DataStorage::SetOfObjects::const_iterator m_PickingObjectsIterator;
 };
 } // namespace mitk
 
 #endif /* MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D */
diff --git a/Core/Code/Testing/files.cmake b/Core/Code/Testing/files.cmake
index f8f8eccce9..ce706d4c00 100644
--- a/Core/Code/Testing/files.cmake
+++ b/Core/Code/Testing/files.cmake
@@ -1,200 +1,199 @@
 # tests with no extra command line parameter
 set(MODULE_TESTS
   # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code.
   #
   #     Example: #mitkMyTest #this test is commented out because of bug 12345
   #
   # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that
   # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and
   # mark it as critical.
 
   ################## DISABLED TESTS #################################################
   #mitkAbstractTransformGeometryTest.cpp #seems as tested class mitkExternAbstractTransformGeometry doesnt exist any more
   #mitkStateMachineContainerTest.cpp #rewrite test, indirect since no longer exported Bug 14529
   #mitkRegistrationBaseTest.cpp #tested class  mitkRegistrationBase doesn't exist any more
   #mitkSegmentationInterpolationTest.cpp #file doesn't exist!
   #mitkPipelineSmartPointerCorrectnessTest.cpp #file doesn't exist!
   #mitkITKThreadingTest.cpp #test outdated because itk::Semaphore was removed from ITK
   #mitkAbstractTransformPlaneGeometryTest.cpp #mitkVtkAbstractTransformPlaneGeometry doesn't exist any more
   #mitkTestUtilSharedLibrary.cpp #Linker problem with this test...
   #mitkTextOverlay2DSymbolsRenderingTest.cpp #Implementation of the tested feature is not finished yet. Ask Christoph or see bug 15104 for details.
 
   ################# RUNNING TESTS ###################################################
   mitkAccessByItkTest.cpp
   mitkCoreObjectFactoryTest.cpp
   mitkMaterialTest.cpp
   mitkActionTest.cpp
   mitkDispatcherTest.cpp
   mitkEnumerationPropertyTest.cpp
   mitkEventTest.cpp
   mitkFocusManagerTest.cpp
   mitkGenericPropertyTest.cpp
-  mitkGeometry2DTest.cpp
   mitkGeometry3DTest.cpp
   mitkGeometry3DEqualTest.cpp
   mitkGeometryDataToSurfaceFilterTest.cpp
   mitkGlobalInteractionTest.cpp
   mitkImageEqualTest.cpp
   mitkImageDataItemTest.cpp
   mitkImageGeneratorTest.cpp
   mitkIOUtilTest.cpp
   mitkBaseDataTest.cpp
   mitkImportItkImageTest.cpp
   mitkGrabItkImageMemoryTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkInteractorTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetEqualTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetReaderTest.cpp
   mitkPointSetInteractorTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkStateMachineTest.cpp
   mitkStateTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceEqualTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
   mitkTimeGeometryTest.cpp
   mitkTransitionTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   mitkStepperTest.cpp
   mitkRenderingManagerTest.cpp
   vtkMitkThickSlicesFilterTest.cpp
   mitkNodePredicateSourceTest.cpp
   mitkVectorTest.cpp
   mitkClippedSurfaceBoundsCalculatorTest.cpp
   mitkExceptionTest.cpp
   mitkExtractSliceFilterTest.cpp
   mitkLogTest.cpp
   mitkImageDimensionConverterTest.cpp
   mitkLoggingAdapterTest.cpp
   mitkUIDGeneratorTest.cpp
   mitkShaderRepositoryTest.cpp
   mitkPlanePositionManagerTest.cpp
   mitkAffineTransformBaseTest.cpp
   mitkPropertyAliasesTest.cpp
   mitkPropertyDescriptionsTest.cpp
   mitkPropertyExtensionsTest.cpp
   mitkPropertyFiltersTest.cpp
   mitkTinyXMLTest.cpp
   mitkRawImageFileReaderTest.cpp
   mitkInteractionEventTest.cpp
   mitkLookupTableTest.cpp
   mitkSTLFileReaderTest.cpp
   mitkSurfaceToImageFilterTest.cpp
   mitkBaseGeometryTest.cpp
   mitkImageToSurfaceFilterTest.cpp
   mitkEqualTest.cpp
 )
 
 if(MITK_ENABLE_RENDERING_TESTING) #since mitkInteractionTestHelper is currently creating a vtkRenderWindow
 set(MODULE_TESTS
   ${MODULE_TESTS}
   mitkPointSetDataInteractorTest.cpp
 )
 endif()
 
 
 # test with image filename as an extra command line parameter
 set(MODULE_IMAGE_TESTS
   mitkImageTimeSelectorTest.cpp #only runs on images
   mitkImageAccessorTest.cpp #only runs on images
   mitkDataNodeFactoryTest.cpp #runs on all types of data
 )
 
 set(MODULE_SURFACE_TESTS
   mitkSurfaceVtkWriterTest.cpp #only runs on surfaces
   mitkDataNodeFactoryTest.cpp #runs on all types of data
 )
 
 # list of images for which the tests are run
 set(MODULE_TESTIMAGES
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   Png2D-bw.png
 )
 set(MODULE_TESTSURFACES
   binary.stl
   ball.stl
 )
 
 set(MODULE_CUSTOM_TESTS
     mitkDataStorageTest.cpp
     mitkDataNodeTest.cpp
     mitkDicomSeriesReaderTest.cpp
     mitkDICOMLocaleTest.cpp
     mitkEventMapperTest.cpp
     mitkEventConfigTest.cpp
     mitkNodeDependentPointSetInteractorTest.cpp
     mitkStateMachineFactoryTest.cpp
     mitkPointSetLocaleTest.cpp
     mitkImageTest.cpp
     mitkImageWriterTest.cpp
     mitkImageVtkMapper2DTest.cpp
     mitkImageVtkMapper2DLevelWindowTest.cpp
     mitkImageVtkMapper2DOpacityTest.cpp
     mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
     mitkImageVtkMapper2DColorTest.cpp
     mitkImageVtkMapper2DSwivelTest.cpp
     mitkImageVtkMapper2DTransferFunctionTest.cpp
     mitkImageVtkMapper2DLookupTableTest.cpp
     mitkSurfaceVtkMapper3DTest
     mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
     mitkSurfaceGLMapper2DColorTest.cpp
     mitkSurfaceGLMapper2DOpacityTest.cpp
     mitkVolumeCalculatorTest.cpp
     mitkLevelWindowManagerTest.cpp
     mitkPointSetVtkMapper2DTest.cpp
     mitkPointSetVtkMapper2DImageTest.cpp
     mitkPointSetVtkMapper2DGlyphTypeTest.cpp
     mitkPointSetVtkMapper2DTransformedPointsTest.cpp
     mitkLabelOverlay3DRendering2DTest.cpp
     mitkLabelOverlay3DRendering3DTest.cpp
     mitkTextOverlay2DRenderingTest.cpp
     mitkTextOverlay2DLayouterRenderingTest.cpp
     mitkTextOverlay3DRendering2DTest.cpp
     mitkTextOverlay3DRendering3DTest.cpp
     mitkTextOverlay3DColorRenderingTest.cpp
     mitkVTKRenderWindowSizeTest.cpp
     mitkMultiComponentImageDataComparisonFilterTest.cpp
     mitkImageToItkTest.cpp
     mitkImageSliceSelectorTest.cpp
     mitkSurfaceDepthPeelingTest.cpp
 )
 
 set(MODULE_RESOURCE_FILES
   Interactions/AddAndRemovePoints.xml
   Interactions/globalConfig.xml
   Interactions/StatemachineTest.xml
   Interactions/StatemachineConfigTest.xml
 )
 
 # Create an artificial module initializing class for
 # the usServiceListenerTest.cpp
 usFunctionGenerateExecutableInit(testdriver_init_file
                                  IDENTIFIER ${MODULE_NAME}TestDriver
                                 )
 
 # Embed the resources
 set(testdriver_resources )
 usFunctionEmbedResources(testdriver_resources
                          EXECUTABLE_NAME ${MODULE_NAME}TestDriver
                          ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Resources
                          FILES ${MODULE_RESOURCE_FILES}
                         )
 
 set(TEST_CPP_FILES ${testdriver_init_file} ${testdriver_resources})
diff --git a/Core/Code/Testing/mitkDataNodeTest.cpp b/Core/Code/Testing/mitkDataNodeTest.cpp
index 23635a286b..5e75b81bb4 100644
--- a/Core/Code/Testing/mitkDataNodeTest.cpp
+++ b/Core/Code/Testing/mitkDataNodeTest.cpp
@@ -1,295 +1,295 @@
 /*===================================================================
 
 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 "mitkDataNode.h"
 
 #include <vtkWindow.h>
 #include "mitkVtkPropRenderer.h"
 
 #include "mitkTestingMacros.h"
 #include "mitkGlobalInteraction.h"
 
 #include <iostream>
 
 //Basedata Test
 #include <mitkRenderWindowFrame.h>
 #include <mitkGeometryData.h>
-#include <mitkGeometry2DData.h>
+#include <mitkPlaneGeometryData.h>
 #include <mitkGradientBackground.h>
 #include <mitkManufacturerLogo.h>
 #include <mitkPointSet.h>
 #include <mitkImage.h>
 #include <mitkSurface.h>
 
 //Mapper Test
-#include <mitkGeometry2DDataMapper2D.h>
-#include <mitkGeometry2DDataMapper2D.h>
+#include <mitkPlaneGeometryDataMapper2D.h>
+#include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkImageVtkMapper2D.h>
 #include <mitkSurfaceGLMapper2D.h>
 
-#include <mitkGeometry2DDataVtkMapper3D.h>
+#include <mitkPlaneGeometryDataVtkMapper3D.h>
 #include <mitkPointSetVtkMapper3D.h>
 #include <mitkPointSetVtkMapper2D.h>
 #include <mitkSurfaceVtkMapper3D.h>
 #include <mitkVolumeDataVtkMapper3D.h>
 
 //Interactors
 #include <mitkAffineInteractor.h>
 #include <mitkPointSetInteractor.h>
 
 //Propertylist Test
 
 
 
 /**
  *  Simple example for a test for the (non-existent) class "DataNode".
  *
  *  argc and argv are the command line parameters which were passed to
  *  the ADD_TEST command in the CMakeLists.txt file. For the automatic
  *  tests, argv is either empty for the simple tests or contains the filename
  *  of a test image for the image tests (see CMakeLists.txt).
  */
 class mitkDataNodeTestClass { public:
 
 static void TestDataSetting(mitk::DataNode::Pointer dataNode)
 {
 
   mitk::BaseData::Pointer baseData;
 
   //NULL pointer Test
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a NULL pointer was set correctly" )
 
   baseData = mitk::RenderWindowFrame::New();
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a RenderWindowFrame object was set correctly" )
 //  MITK_TEST_CONDITION( baseData->GetGeometry(0)->GetVtkTransform() == dataNode->GetVtkTransform(0), "Testing if a NULL pointer was set correctly" )
 
   baseData = mitk::GeometryData::New();
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a GeometryData object was set correctly" )
 
-  baseData = mitk::Geometry2DData::New();
+  baseData = mitk::PlaneGeometryData::New();
   dataNode->SetData(baseData);
-  MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a Geometry2DData object was set correctly" )
+  MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a PlaneGeometryData object was set correctly" )
 
   baseData = mitk::GradientBackground::New();
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a GradientBackground object was set correctly" )
 
   baseData = mitk::ManufacturerLogo::New();
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a ManufacturerLogo object was set correctly" )
 
   baseData = mitk::PointSet::New();
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a PointSet object was set correctly" )
 
   baseData = mitk::Image::New();
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a Image object was set correctly" )
 
   baseData = mitk::Surface::New();
   dataNode->SetData(baseData);
   MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a Surface object was set correctly" )
 }
 static void TestMapperSetting(mitk::DataNode::Pointer dataNode)
 {
   //tests the SetMapper() method
   //in dataNode is a mapper vector which can be accessed by index
   //in this test method we use only slot 0 (filled with null) and slot 1
   //so we also test the destructor of the mapper classes
   mitk::Mapper::Pointer mapper;
 
   dataNode->SetMapper(0,mapper);
   MITK_TEST_CONDITION( mapper == dataNode->GetMapper(0), "Testing if a NULL pointer was set correctly" )
 
-  mapper = mitk::Geometry2DDataMapper2D::New();
+  mapper = mitk::PlaneGeometryDataMapper2D::New();
   dataNode->SetMapper(1,mapper);
-  MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a Geometry2DDataMapper2D was set correctly" )
+  MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PlaneGeometryDataMapper2D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
   mapper = mitk::ImageVtkMapper2D::New();
   dataNode->SetMapper(1,mapper);
   MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a ImageVtkMapper2D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
   mapper = mitk::PointSetVtkMapper2D::New();
   dataNode->SetMapper(1,mapper);
   MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper2D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
   mapper = mitk::SurfaceGLMapper2D::New();
   dataNode->SetMapper(1,mapper);
   MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a SurfaceGLMapper2D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
-  mapper = mitk::Geometry2DDataVtkMapper3D::New();
+  mapper = mitk::PlaneGeometryDataVtkMapper3D::New();
   dataNode->SetMapper(1,mapper);
-  MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a Geometry2DDataVtkMapper3D was set correctly" )
+  MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PlaneGeometryDataVtkMapper3D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
   mapper = mitk::PointSetVtkMapper3D::New();
   dataNode->SetMapper(1,mapper);
   MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper3D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
   mapper = mitk::SurfaceVtkMapper3D::New();
   dataNode->SetMapper(1,mapper);
   MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a SurfaceVtkMapper3D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
   mapper = mitk::VolumeDataVtkMapper3D::New();
   dataNode->SetMapper(1,mapper);
   MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a VolumeDataVtkMapper3D was set correctly" )
   MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 
   //linker error
   //mapper = mitk::LineVtkMapper3D::New();
   //dataNode->SetMapper(1,mapper);
   //MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a LineVtkMapper3D was set correctly" )
   //MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
 }
 static void TestInteractorSetting(mitk::DataNode::Pointer dataNode)
 {
 
   //this method tests the SetInteractor() and GetInteractor methods
   //the Interactor base class calls the DataNode->SetInteractor method
 
   mitk::Interactor::Pointer interactor;
 
   MITK_TEST_CONDITION( interactor == dataNode->GetInteractor(), "Testing if a NULL pointer was set correctly (Interactor)" )
 
   interactor = mitk::AffineInteractor::New("AffineInteractions click to select", dataNode);
   dataNode->EnableInteractor();
   dataNode->DisableInteractor();
   MITK_TEST_CONDITION( interactor == dataNode->GetInteractor(), "Testing if a AffineInteractor was set correctly" )
 
   interactor = mitk::PointSetInteractor::New("AffineInteractions click to select", dataNode);
   MITK_TEST_CONDITION( interactor == dataNode->GetInteractor(), "Testing if a PointSetInteractor was set correctly" )
 }
 static void TestPropertyList(mitk::DataNode::Pointer dataNode)
 {
 
   mitk::PropertyList::Pointer propertyList =  dataNode->GetPropertyList();
 
 
   MITK_TEST_CONDITION(dataNode->GetPropertyList() != NULL, "Testing if the constructor set the propertylist" )
 
   dataNode->SetIntProperty("int", -31337);
   int x;
   dataNode->GetIntProperty("int", x);
   MITK_TEST_CONDITION(x == -31337, "Testing Set/GetIntProperty");
 
   dataNode->SetBoolProperty("bool", true);
   bool b;
   dataNode->GetBoolProperty("bool", b);
   MITK_TEST_CONDITION(b == true, "Testing Set/GetBoolProperty");
   dataNode->SetFloatProperty("float", -31.337);
   float y;
   dataNode->GetFloatProperty("float", y);
   MITK_TEST_CONDITION(y - -31.337 < 0.01, "Testing Set/GetFloatProperty");
   dataNode->SetStringProperty("string", "MITK");
   std::string s = "GANZVIELPLATZ";
   dataNode->GetStringProperty("string", s);
   MITK_TEST_CONDITION(s == "MITK", "Testing Set/GetStringProperty");
 
   std::string name = "MyTestName";
   dataNode->SetName(name.c_str());
   MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName");
   name = "MySecondTestName";
   dataNode->SetName(name);
   MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName(std::string)");
 
   MITK_TEST_CONDITION(propertyList == dataNode->GetPropertyList(), "Testing if the propertylist has changed during the last tests" )
 }
 
 static void TestSelected(mitk::DataNode::Pointer dataNode)
 {
   vtkRenderWindow *renderWindow = vtkRenderWindow::New();
 
   mitk::VtkPropRenderer::Pointer base = mitk::VtkPropRenderer::New( "the first renderer", renderWindow, mitk::RenderingManager::GetInstance() );
 
   //with BaseRenderer==Null
   MITK_TEST_CONDITION(!dataNode->IsSelected(), "Testing if this node is not set as selected" )
 
   dataNode->SetSelected(true);
   MITK_TEST_CONDITION(dataNode->IsSelected(), "Testing if this node is set as selected" )
   dataNode->SetSelected(false);
 
   dataNode->SetSelected(true,base);
 
   MITK_TEST_CONDITION(dataNode->IsSelected(base), "Testing if this node with right base renderer is set as selected" )
 
   //Delete RenderWindow correctly
   renderWindow->Delete();
 
 }
 static void TestGetMTime(mitk::DataNode::Pointer dataNode)
 {
   unsigned long time;
   time = dataNode->GetMTime();
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
 
   dataNode->SetData(pointSet);
   MITK_TEST_CONDITION( time != dataNode->GetMTime(), "Testing if the node timestamp is updated after adding data to the node" )
 
   mitk::Point3D point;
   point.Fill(3.0);
   pointSet->SetPoint(0,point);
 
   //less or equal because dataNode timestamp is little later then the basedata timestamp
   MITK_TEST_CONDITION( pointSet->GetMTime() <= dataNode->GetMTime(), "Testing if the node timestamp is updated after base data was modified" )
 
   // testing if changing anything in the property list also sets the node in a modified state
   unsigned long lastModified = dataNode->GetMTime();
   dataNode->SetIntProperty("testIntProp", 2344);
   MITK_TEST_CONDITION( lastModified <= dataNode->GetMTime(), "Testing if the node timestamp is updated after property list was modified" )
 
 }
 }; //mitkDataNodeTestClass
 int mitkDataNodeTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("DataNode")
 
   // Global interaction must(!) be initialized
   mitk::GlobalInteraction::GetInstance()->Initialize("global");
 
   // let's create an object of our class
   mitk::DataNode::Pointer myDataNode = mitk::DataNode::New();
 
   // first test: did this work?
   // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
   // it makes no sense to continue without an object.
   MITK_TEST_CONDITION_REQUIRED(myDataNode.IsNotNull(),"Testing instantiation")
 
   //test setData() Method
   mitkDataNodeTestClass::TestDataSetting(myDataNode);
   mitkDataNodeTestClass::TestMapperSetting(myDataNode);
   //
   //note, that no data is set to the dataNode
   mitkDataNodeTestClass::TestInteractorSetting(myDataNode);
   mitkDataNodeTestClass::TestPropertyList(myDataNode);
   mitkDataNodeTestClass::TestSelected(myDataNode);
   mitkDataNodeTestClass::TestGetMTime(myDataNode);
 
   // write your own tests here and use the macros from mitkTestingMacros.h !!!
   // do not write to std::cout and do not return from this function yourself!
 
   // always end with this!
   MITK_TEST_END()
 }
diff --git a/Core/Code/Testing/mitkGeometry2DTest.cpp b/Core/Code/Testing/mitkGeometry2DTest.cpp
deleted file mode 100644
index a99c42438d..0000000000
--- a/Core/Code/Testing/mitkGeometry2DTest.cpp
+++ /dev/null
@@ -1,157 +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 "mitkGeometry3D.h"
-
-#include <vnl/vnl_quaternion.h>
-#include <vnl/vnl_quaternion.txx>
-
-#include "mitkRotationOperation.h"
-#include "mitkInteractionConst.h"
-#include <mitkMatrixConvert.h>
-#include <mitkImageCast.h>
-
-#include "mitkTestingMacros.h"
-#include <fstream>
-#include <mitkVector.h>
-
-
-mitk::PlaneGeometry::Pointer  createGeometry2D()
-{
-   mitk::Vector3D mySpacing;
-   mySpacing[0] = 31;
-   mySpacing[1] = 0.1;
-   mySpacing[2] = 5.4;
-   mitk::Point3D myOrigin;
-   myOrigin[0] = 8;
-   myOrigin[1] = 9;
-   myOrigin[2] = 10;
-   mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
-   itk::Matrix<mitk::ScalarType, 3,3> transMatrix;
-   transMatrix.Fill(0);
-   transMatrix[0][0] = 1;
-   transMatrix[1][1] = 2;
-   transMatrix[2][2] = 4;
-
-   myTransform->SetMatrix(transMatrix);
-
-   mitk::PlaneGeometry::Pointer geometry2D = mitk::PlaneGeometry::New();
-   geometry2D->SetIndexToWorldTransform(myTransform);
-   geometry2D->SetSpacing(mySpacing);
-   geometry2D->SetOrigin(myOrigin);
-   return geometry2D;
-}
-
-int testGeometry2DCloning()
-{
-  mitk::PlaneGeometry::Pointer geometry2D = createGeometry2D();
-
-  try
-  {
-    mitk::PlaneGeometry::Pointer clone = geometry2D->Clone();
-    itk::Matrix<mitk::ScalarType,3,3> matrix = clone->GetIndexToWorldTransform()->GetMatrix();
-    MITK_TEST_CONDITION(matrix[0][0] == 31, "Test if matrix element exists...");
-
-    double origin = geometry2D->GetOrigin()[0];
-    MITK_TEST_CONDITION(mitk::Equal(origin, 8),"First Point of origin as expected...");
-
-    double spacing = geometry2D->GetSpacing()[0];
-    MITK_TEST_CONDITION(mitk::Equal(spacing, 31),"First Point of spacing as expected...");
-  }
-  catch (...)
-  {
-    MITK_TEST_CONDITION(false, "Error during access on a member of cloned geometry");
-  }
-   // direction [row] [coloum]
-   MITK_TEST_OUTPUT( << "Casting a rotated 2D ITK Image to a MITK Image and check if Geometry is still same" );
-
-  return EXIT_SUCCESS;
-}
-
-bool compareMatrix(itk::Matrix<mitk::ScalarType, 3,3> left, itk::Matrix<mitk::ScalarType, 3,3> right)
-{
-  bool equal = true;
-  for (int i = 0; i < 3; ++i)
-    for (int j = 0; j < 3; ++j)
-      equal &= mitk::Equal(left[i][j], right[i][j]);
-  return equal;
-}
-
-int testGeometry2DInitializeOrder()
-{
-   mitk::Vector3D mySpacing;
-   mySpacing[0] = 31;
-   mySpacing[1] = 0.1;
-   mySpacing[2] = 5.4;
-   mitk::Point3D myOrigin;
-   myOrigin[0] = 8;
-   myOrigin[1] = 9;
-   myOrigin[2] = 10;
-   mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
-   itk::Matrix<mitk::ScalarType, 3,3> transMatrix;
-   transMatrix.Fill(0);
-   transMatrix[0][0] = 1;
-   transMatrix[1][1] = 2;
-   transMatrix[2][2] = 4;
-
-   myTransform->SetMatrix(transMatrix);
-
-   mitk::PlaneGeometry::Pointer geometry2D1 = mitk::PlaneGeometry::New();
-   geometry2D1->SetIndexToWorldTransform(myTransform);
-   geometry2D1->SetSpacing(mySpacing);
-   geometry2D1->SetOrigin(myOrigin);
-
-   mitk::PlaneGeometry::Pointer geometry2D2 = mitk::PlaneGeometry::New();
-   geometry2D2->SetSpacing(mySpacing);
-   geometry2D2->SetOrigin(myOrigin);
-   geometry2D2->SetIndexToWorldTransform(myTransform);
-
-   mitk::PlaneGeometry::Pointer geometry2D3 = mitk::PlaneGeometry::New();
-   geometry2D3->SetIndexToWorldTransform(myTransform);
-   geometry2D3->SetSpacing(mySpacing);
-   geometry2D3->SetOrigin(myOrigin);
-   geometry2D3->SetIndexToWorldTransform(myTransform);
-
-   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetOrigin(), geometry2D2->GetOrigin()),"Origin of Geometry 1 match those of Geometry 2.");
-   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetOrigin(), geometry2D3->GetOrigin()),"Origin of Geometry 1 match those of Geometry 3.");
-   MITK_TEST_CONDITION(mitk::Equal(geometry2D2->GetOrigin(), geometry2D3->GetOrigin()),"Origin of Geometry 2 match those of Geometry 3.");
-
-   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetSpacing(), geometry2D2->GetSpacing()),"Spacing of Geometry 1 match those of Geometry 2.");
-   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetSpacing(), geometry2D3->GetSpacing()),"Spacing of Geometry 1 match those of Geometry 3.");
-   MITK_TEST_CONDITION(mitk::Equal(geometry2D2->GetSpacing(), geometry2D3->GetSpacing()),"Spacing of Geometry 2 match those of Geometry 3.");
-
-   MITK_TEST_CONDITION(compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(), geometry2D2->GetIndexToWorldTransform()->GetMatrix()),"Transformation of Geometry 1 match those of Geometry 2.");
-   MITK_TEST_CONDITION(compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(), geometry2D3->GetIndexToWorldTransform()->GetMatrix()),"Transformation of Geometry 1 match those of Geometry 3.");
-   MITK_TEST_CONDITION(compareMatrix(geometry2D2->GetIndexToWorldTransform()->GetMatrix(), geometry2D3->GetIndexToWorldTransform()->GetMatrix()),"Transformation of Geometry 2 match those of Geometry 3.");
-   return EXIT_SUCCESS;
-}
-
-int mitkGeometry2DTest(int /*argc*/, char* /*argv*/[])
-{
-  MITK_TEST_BEGIN(mitkGeometry3DTest);
-
-  int result;
-
-  MITK_TEST_CONDITION_REQUIRED ( (result = testGeometry2DCloning()) == EXIT_SUCCESS, "");
-
-  // See bug 15990
-  // MITK_TEST_CONDITION_REQUIRED ( (result = testGeometry2DInitializeOrder()) == EXIT_SUCCESS, "");
-
-
-  MITK_TEST_END();
-
-  return EXIT_SUCCESS;
-}
diff --git a/Core/Code/Testing/mitkGeometryDataToSurfaceFilterTest.cpp b/Core/Code/Testing/mitkGeometryDataToSurfaceFilterTest.cpp
index 9407e0fda3..2d7df08084 100644
--- a/Core/Code/Testing/mitkGeometryDataToSurfaceFilterTest.cpp
+++ b/Core/Code/Testing/mitkGeometryDataToSurfaceFilterTest.cpp
@@ -1,253 +1,253 @@
 /*===================================================================
 
 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 "mitkGeometry2DDataToSurfaceFilter.h"
+#include "mitkPlaneGeometryDataToSurfaceFilter.h"
 
 #include "mitkSurface.h"
 #include "mitkPlaneGeometry.h"
-#include "mitkGeometry2DData.h"
+#include "mitkPlaneGeometryData.h"
 
 #include "vtkPolyData.h"
 
 #include <fstream>
 
 template <typename TScalarType>
 int testExpectedIndexBoundingBox(mitk::BaseGeometry* geometry, TScalarType expectedIndexBounds[6])
 {
   mitk::BoundingBox* bb = const_cast<mitk::BoundingBox*>(geometry->GetBoundingBox());
   mitk::BoundingBox::BoundsArrayType bounds = bb->GetBounds();
 
   int i;
   for(i=0;i<6;++i)
   {
     if( mitk::Equal(bounds[i], expectedIndexBounds[i]) == false)
     {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
     }
   }
   std::cout<<"[PASSED]"<<std::endl;
   return EXIT_SUCCESS;
 }
 
 template <typename TScalarType>
 int testExpectedAxisParallelBoundingBox(mitk::BaseGeometry* geometry, TScalarType expectedAxisParallelBounds[6])
 {
   mitk::BoundingBox::Pointer bb = geometry->CalculateBoundingBoxRelativeToTransform(NULL);
   mitk::BoundingBox::BoundsArrayType bounds = bb->GetBounds();
 
   int i;
   for(i=0;i<6;++i)
   {
     if( mitk::Equal(bounds[i], expectedAxisParallelBounds[i]) == false)
     {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
     }
   }
   std::cout<<"[PASSED]"<<std::endl;
   return EXIT_SUCCESS;
 }
 
 int testSurfaceBoundingBoxConsistency(mitk::Surface* surface, bool expectIdentityTransform)
 {
   int result;
   std::cout << "  Testing surface contents: ";
   if ((surface ==  NULL )
     || (surface->GetVtkPolyData() == NULL)
     || (surface->GetVtkPolyData()->GetNumberOfPoints() == 0 )) {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   else {
     std::cout<<"[PASSED]"<<std::endl;
   }
 
   double bounds[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
 
   vtkPolyData* polys = surface->GetVtkPolyData();
   polys->ComputeBounds();
   polys->GetBounds( bounds );
 
   int i;
   if(expectIdentityTransform == false)
   {
     mitk::PlaneGeometry::Pointer geometry = mitk::PlaneGeometry::New();
     geometry->SetFloatBounds(bounds);
     geometry->SetIndexToWorldTransform(surface->GetGeometry()->GetIndexToWorldTransform());
     mitk::BoundingBox::BoundsArrayType bb = const_cast<mitk::BoundingBox*>(geometry->GetBoundingBox())->GetBounds();
     for(i=0;i<6;++i)
       bounds[i]=bb[i];
   }
 
   std::cout << "  Testing GetBoundingBox() ";
   if((result=testExpectedIndexBoundingBox(surface->GetGeometry(), bounds)) != EXIT_SUCCESS)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   return EXIT_SUCCESS;
 }
 
-int testGeometryDataToSurfaceFilter(mitk::Geometry2DDataToSurfaceFilter* geometryToSurfaceFilter, mitk::ScalarType expectedIndexBounds[6], mitk::ScalarType expectedAxisParallelBounds[6], bool expectIdentityTransform)
+int testGeometryDataToSurfaceFilter(mitk::PlaneGeometryDataToSurfaceFilter* geometryToSurfaceFilter, mitk::ScalarType expectedIndexBounds[6], mitk::ScalarType expectedAxisParallelBounds[6], bool expectIdentityTransform)
 {
   int result;
 
   std::cout << "Testing SetRequestedRegionToLargestPossibleRegion(): ";
   geometryToSurfaceFilter->GetOutput()->SetRequestedRegionToLargestPossibleRegion();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing UpdateOutputInformation(): ";
   geometryToSurfaceFilter->UpdateOutputInformation();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing correctness of bounding-box after UpdateOutputInformation(): ";
   if((result=testExpectedIndexBoundingBox(geometryToSurfaceFilter->GetOutput()->GetGeometry(), expectedIndexBounds)) != EXIT_SUCCESS) {
     return result;
   }
 
   std::cout << "Testing correctness of axis-parallel bounding-box after UpdateOutputInformation(): ";
   if((result=testExpectedAxisParallelBoundingBox(geometryToSurfaceFilter->GetOutput()->GetGeometry(), expectedAxisParallelBounds)) != EXIT_SUCCESS) {
     return result;
   }
 
 
   std::cout << "Testing Update(): ";
   geometryToSurfaceFilter->Update();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing correctness of bounding-box after Update(): ";
   if((result=testExpectedIndexBoundingBox(geometryToSurfaceFilter->GetOutput()->GetGeometry(), expectedIndexBounds)) != EXIT_SUCCESS) {
     return result;
   }
 
   std::cout << "Testing correctness of axis-parallel bounding-box after UpdateOutputInformation(): ";
   if((result=testExpectedAxisParallelBoundingBox(geometryToSurfaceFilter->GetOutput()->GetGeometry(), expectedAxisParallelBounds)) != EXIT_SUCCESS) {
     return result;
   }
 
   std::cout << "Testing bounding-box consistency: "<<std::endl;
   if((result=testSurfaceBoundingBoxConsistency(geometryToSurfaceFilter->GetOutput(), expectIdentityTransform)) != EXIT_SUCCESS) {
     std::cout<<"[FAILED]"<<std::endl;
     return result;
   }
   else {
     std::cout<<"[PASSED]"<<std::endl;
   }
   return EXIT_SUCCESS;
 }
 
 int mitkGeometryDataToSurfaceFilterTest(int /*argc*/, char* /*argv*/[])
 {
   int result;
 
-  std::cout << "Testing mitk::Geometry2DDataToSurfaceFilter: " << std::endl;
+  std::cout << "Testing mitk::PlaneGeometryDataToSurfaceFilter: " << std::endl;
 
-  mitk::Geometry2DDataToSurfaceFilter::Pointer geometryToSurfaceFilter;
-  std::cout << "Testing Geometry2DDataToSurfaceFilter::New(): ";
-  geometryToSurfaceFilter = mitk::Geometry2DDataToSurfaceFilter::New();
+  mitk::PlaneGeometryDataToSurfaceFilter::Pointer geometryToSurfaceFilter;
+  std::cout << "Testing PlaneGeometryDataToSurfaceFilter::New(): ";
+  geometryToSurfaceFilter = mitk::PlaneGeometryDataToSurfaceFilter::New();
   if (geometryToSurfaceFilter.IsNull()) {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   else {
     std::cout<<"[PASSED]"<<std::endl;
   }
 
   mitk::Point3D origin;
   mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
   plane->InitializeStandardPlane(50, 100);
   mitk::FillVector3D(origin, 1.0, 2.0, 3.0);
   plane->SetOrigin(origin);
 
-  mitk::Geometry2DData::Pointer geometryData = mitk::Geometry2DData::New();
-  geometryData->SetGeometry2D(plane);
+  mitk::PlaneGeometryData::Pointer geometryData = mitk::PlaneGeometryData::New();
+  geometryData->SetPlaneGeometry(plane);
 
   std::cout << "Testing SetInput(): ";
   geometryToSurfaceFilter->SetInput(geometryData);
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetInput(): ";
   if (geometryToSurfaceFilter->GetInput() !=  geometryData ) {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   else {
     std::cout<<"[PASSED]"<<std::endl;
   }
 
 
-  std::cout << "Testing default of Geometry2DDataToSurfaceFilter::m_PlaceByGeometry (expected is false): ";
+  std::cout << "Testing default of PlaneGeometryDataToSurfaceFilter::m_PlaceByGeometry (expected is false): ";
   if (geometryToSurfaceFilter->GetPlaceByGeometry() !=  false ) {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   else {
     std::cout<<"[PASSED]"<<std::endl;
   }
 
   // test with m_PlaceByGeometry==false
   mitk::ScalarType expectedBoundsFinal[6] = {1.0, 51.0, 2.0, 102.0, 3.0, 3.0};
   if((result=testGeometryDataToSurfaceFilter(geometryToSurfaceFilter, expectedBoundsFinal, expectedBoundsFinal, true)) != EXIT_SUCCESS) {
     return result;
   }
 
-  std::cout << "Testing Geometry2DDataToSurfaceFilter::SetPlaceByGeometry(true): ";
+  std::cout << "Testing PlaneGeometryDataToSurfaceFilter::SetPlaceByGeometry(true): ";
   geometryToSurfaceFilter->SetPlaceByGeometry(true);
   if (geometryToSurfaceFilter->GetPlaceByGeometry() !=  true ) {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   else {
     std::cout<<"[PASSED]"<<std::endl;
   }
 
   // test with m_PlaceByGeometry==true
   mitk::ScalarType expectedIndexBounds[6] = {0.0, 50.0, 0.0, 100.0, 0.0, 0.0};
   mitk::ScalarType expectedAxisParallelBounds[6] = {1.0, 51.0, 2.0, 102.0, 3.0, 3.0};
   if((result=testGeometryDataToSurfaceFilter(geometryToSurfaceFilter, expectedIndexBounds, expectedAxisParallelBounds, true)) != EXIT_SUCCESS) {
     return result;
   }
 
 
 
   // test with specified BoundingBox (m_PlaceByGeometry is irrelevant for this test)
   mitk::BoundingBox::Pointer boundingBox = mitk::BoundingBox::New();
   mitk::Point3D bbMin, bbMax;
   mitk::FillVector3D( bbMin, 10.0, 10.0, -6.0 );
   mitk::FillVector3D( bbMax, 40.0, 90.0, 6.0 );
 
   mitk::BoundingBox::PointsContainer::Pointer pointsContainer = mitk::BoundingBox::PointsContainer::New();
   pointsContainer->InsertElement( 0, bbMin );
   pointsContainer->InsertElement( 1, bbMax );
   boundingBox->SetPoints( pointsContainer );
   boundingBox->ComputeBoundingBox();
 
 
   geometryToSurfaceFilter->SetPlaceByGeometry( true );
   geometryToSurfaceFilter->SetBoundingBox( boundingBox );
   mitk::ScalarType expectedIndexBoundsWithBB[6] = {9.0, 39.0, 8.0, 88.0, 0.0, 0.0};
   mitk::ScalarType expectedAxisParallelBoundsWithBB[6] = {10.0, 40.0, 10.0, 90.0, 3.0, 3.0};
   if((result=testGeometryDataToSurfaceFilter(geometryToSurfaceFilter, expectedIndexBoundsWithBB, expectedAxisParallelBoundsWithBB, true)) != EXIT_SUCCESS) {
     return result;
   }
 
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
diff --git a/Core/Code/Testing/mitkImageTest.cpp b/Core/Code/Testing/mitkImageTest.cpp
index ddcfe231d3..ffbbc84044 100644
--- a/Core/Code/Testing/mitkImageTest.cpp
+++ b/Core/Code/Testing/mitkImageTest.cpp
@@ -1,526 +1,526 @@
 /*===================================================================
 
 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 includes
 #include <mitkImage.h>
 #include <mitkImageDataItem.h>
 #include <mitkImageCast.h>
 #include "mitkItkImageFileReader.h"
 #include <mitkTestingMacros.h>
 #include <mitkImageStatisticsHolder.h>
 #include "mitkImageGenerator.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkException.h"
 #include "mitkPixelTypeMultiplex.h"
 #include "mitkImagePixelReadAccessor.h"
 
 #include "mitkImageSliceSelector.h"
 
 // itk includes
 #include <itkImage.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 
 // stl includes
 #include <fstream>
 
 // vtk includes
 #include <vtkImageData.h>
 
 // Checks if reference count is correct after using GetVtkImageData()
 bool ImageVtkDataReferenceCheck(const char* fname) {
 
   const std::string filename = std::string(fname);
   mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
   try
   {
     imageReader->SetFileName(filename);
     imageReader->Update();
   }
   catch(...) {
     MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
     return false;
   }
 
   {
     mitk::Image::Pointer image = imageReader->GetOutput();
     vtkImageData* vtk = image->GetVtkImageData();
 
     if(vtk == NULL)
       return false;
   }
 
   return true;
 }
 
 template <class T>
 void TestRandomPixelAccess( const mitk::PixelType ptype, mitk::Image::Pointer image, mitk::Point3D & point, mitk::ScalarType & value )
 {
   // generate a random point in world coordinates
   mitk::Point3D xMax, yMax, zMax, xMaxIndex, yMaxIndex, zMaxIndex;
   xMaxIndex.Fill(0.0f);
   yMaxIndex.Fill(0.0f);
   zMaxIndex.Fill(0.0f);
   xMaxIndex[0] = image->GetLargestPossibleRegion().GetSize()[0];
   yMaxIndex[1] = image->GetLargestPossibleRegion().GetSize()[1];
   zMaxIndex[2] = image->GetLargestPossibleRegion().GetSize()[2];
   image->GetGeometry()->IndexToWorld(xMaxIndex, xMax);
   image->GetGeometry()->IndexToWorld(yMaxIndex, yMax);
   image->GetGeometry()->IndexToWorld(zMaxIndex, zMax);
   MITK_INFO << "Origin " << image->GetGeometry()->GetOrigin()[0] << " "<< image->GetGeometry()->GetOrigin()[1] << " "<< image->GetGeometry()->GetOrigin()[2] << "";
   MITK_INFO << "MaxExtend " << xMax[0] << " "<< yMax[1] << " "<< zMax[2] << "";
 
   itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
   randomGenerator->Initialize( std::rand() );      // initialize with random value, to get sensible random points for the image
   point[0] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[0], xMax[0]);
   point[1] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[1], yMax[1]);
   point[2] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[2], zMax[2]);
   MITK_INFO << "RandomPoint " << point[0] << " "<< point[1] << " "<< point[2] << "";
 
   // test values and max/min
   mitk::ScalarType imageMin = image->GetStatistics()->GetScalarValueMin();
   mitk::ScalarType imageMax = image->GetStatistics()->GetScalarValueMax();
 
   // test accessing PixelValue with coordinate leading to a negative index
   const mitk::Point3D geom_origin = image->GetGeometry()->GetOrigin();
   const mitk::Point3D geom_center = image->GetGeometry()->GetCenter();
 
   // shift position from origin outside of the image ( in the opposite direction to [center-origin] vector which points in the inside)
   mitk::Point3D position = geom_origin + (geom_origin - geom_center);
 
   MITK_INFO << "Testing access outside of the image";
   unsigned int dim = image->GetDimension();
   if(dim == 3 || dim == 4){
     mitk::ImagePixelReadAccessor<T,3> imAccess3(image,image->GetVolumeData(0));
 
     // Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
     // (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
     // bug-11978 : we still need to catch index with negative values
     if ( point[0] < 0 ||
          point[1] < 0 ||
          point[2] < 0 )
     {
       MITK_WARN << "Given position ("<< point << ") is out of image range, returning 0." ;
     }
     else {
       value = static_cast<mitk::ScalarType>(imAccess3.GetPixelByWorldCoordinates(point));
       MITK_TEST_CONDITION( (value >= imageMin && value <= imageMax), "Value returned is between max/min");
     }
     mitk::Index3D itkIndex;
     image->GetGeometry()->WorldToIndex(position, itkIndex);
     MITK_TEST_FOR_EXCEPTION_BEGIN(mitk::Exception);
     imAccess3.GetPixelByIndexSafe(itkIndex);
     MITK_TEST_FOR_EXCEPTION_END(mitk::Exception);
   }
   MITK_INFO << imageMin << " "<< imageMax << " "<< value << "";
 
 }
 
 class mitkImageTestClass
 {
 public:
   void SetClonedGeometry_None_ClonedEqualInput()
   {
     mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(100, 100, 100, 1, 0.2, 0.3, 0.4);
 
     //-----------------
     // geometry information for image
     mitk::Point3D origin;
     mitk::Vector3D right, bottom;
     mitk::Vector3D spacing;
     mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
     mitk::FillVector3D(right, 1.0, 2.0, 3.0);
     mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
     mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
 
     //InitializeStandardPlane(rightVector, downVector, spacing)
     mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
     planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
     planegeometry->SetOrigin(origin);
     planegeometry->ChangeImageGeometryConsideringOriginOffset(true);
 
     image->SetClonedGeometry(planegeometry);
 
     mitk::BaseGeometry::Pointer imageGeometry = image->GetGeometry();
     itk::ScalableAffineTransform<mitk::ScalarType,3>* frameNew = imageGeometry->GetIndexToWorldTransform();
     itk::ScalableAffineTransform<mitk::ScalarType,3>* frameOld = planegeometry->GetIndexToWorldTransform();
     bool matrixEqual = true;
     for (int i = 0; i < 16; ++i)
     {
       double valueNew = *(frameNew->GetMatrix()[i]);
       double valueOld = *(frameOld->GetMatrix()[i]);
 
       //MITK_INFO << "Index: " << i << " Old: " << valueOld << " New: " << valueNew << " Difference:" << valueOld-valueNew<< std::endl;
       matrixEqual = matrixEqual && mitk::Equal(valueNew, valueOld, mitk::eps);
     }
 
     // Disabled because this test fails on the dashboard. Does not fail on my machine.
     // See Bug 6505
     //    MITK_TEST_CONDITION(matrixEqual, "Matrix elements of cloned matrix equal original matrix");
 
   }
 };
 
 
 int mitkImageTest(int argc, char* argv[])
 {
 
   MITK_TEST_BEGIN(mitkImageTest);
 
   mitkImageTestClass tester;
   tester.SetClonedGeometry_None_ClonedEqualInput();
 
 
   //Create Image out of nowhere
   mitk::Image::Pointer imgMem = mitk::Image::New();
   mitk::PixelType pt = mitk::MakeScalarPixelType<int>();
   unsigned int dim[]={100,100,20};
 
   MITK_TEST_CONDITION_REQUIRED( imgMem.IsNotNull(), "An image was created. ");
 
   // Initialize image
   imgMem->Initialize( pt, 3, dim);
 
   MITK_TEST_CONDITION_REQUIRED( imgMem->IsInitialized(), "Image::IsInitialized() ?");
   MITK_TEST_CONDITION_REQUIRED( imgMem->GetPixelType() == pt, "PixelType was set correctly.");
 
 
   int *p = NULL;
   int *p2 = NULL;
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION( p != NULL, "GetData() returned not-NULL pointer.");
 
   // filling image
   const unsigned int size = dim[0]*dim[1]*dim[2];
   for(unsigned int i=0; i<size; ++i, ++p)
     *p = (signed int)i;
 
   // Getting it again and compare with filled values:
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p2 = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION( p2 != NULL, "GetData() returned not-NULL pointer.");
 
   bool isEqual = true;
   for(unsigned int i=0; i<size; ++i, ++p2)
   {
     if(*p2 != (signed int) i )
     {
       isEqual = false;
     }
   }
   MITK_TEST_CONDITION( isEqual, "The values previously set as data are correct [pixelwise comparison].");
 
   // Testing GetSliceData() and compare with filled values:
 
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem, imgMem->GetSliceData(dim[2]/2));
     p2 = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION_REQUIRED( p2 != NULL, "Valid slice data returned");
 
   unsigned int xy_size = dim[0]*dim[1];
   unsigned int start_mid_slice = (dim[2]/2)*xy_size;
   isEqual = true;
   for(unsigned int i=0; i<xy_size; ++i, ++p2)
   {
     if(*p2!=(signed int)(i+start_mid_slice))
     {
       isEqual = false;
     }
   }
   MITK_TEST_CONDITION( isEqual, "The SliceData are correct [pixelwise comparison]. ");
 
   imgMem = mitk::Image::New();
 
   // testing re-initialization of test image
   mitk::PixelType pType = mitk::MakePixelType<int, int, 1>();
   imgMem->Initialize( pType , 3, dim);
   MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension()== 3, "Testing initialization parameter dimension!");
   MITK_TEST_CONDITION_REQUIRED(imgMem->GetPixelType() ==  pType, "Testing initialization parameter pixeltype!");
   MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension(0) == dim[0] &&
     imgMem->GetDimension(1)== dim[1] && imgMem->GetDimension(2)== dim[2], "Testing initialization of dimensions!");
   MITK_TEST_CONDITION( imgMem->IsInitialized(), "Image is initialized.");
 
   // Setting volume again:
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     imgMem->SetVolume(imgMemAcc.GetData());
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
 
   //-----------------
   // geometry information for image
   mitk::Point3D origin;
   mitk::Vector3D right, bottom;
   mitk::Vector3D spacing;
   mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
   mitk::FillVector3D(right, 1.0, 2.0, 3.0);
   mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
   mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
 
   //InitializeStandardPlane(rightVector, downVector, spacing)
   mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
   planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
   planegeometry->SetOrigin(origin);
 
   // Testing Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int slices) with PlaneGeometry and GetData(): ";
   imgMem->Initialize( mitk::MakePixelType<int, int, 1>(), *planegeometry);
   MITK_TEST_CONDITION_REQUIRED( imgMem->GetGeometry()->GetOrigin() == static_cast<mitk::BaseGeometry*>(planegeometry)->GetOrigin(), "Testing correct setting of geometry via initialize!");
 
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION_REQUIRED( p!=NULL, "GetData() returned valid pointer.");
 
   // Testing Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry) and GetData(): ";
   imgMem->Initialize( mitk::MakePixelType<int, int, 1>() , 40, *planegeometry);
 
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION_REQUIRED( p != NULL, "GetData() returned valid pointer.");
 
   //-----------------
   // testing origin information and methods
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of origin via GetGeometry()->GetOrigin(): ");
 
   // Setting origin via SetOrigin(origin): ";
   mitk::FillVector3D(origin, 37.0, 17.92, 27.83);  imgMem->SetOrigin(origin);
 
   // Test origin
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of changed origin via GetGeometry()->GetOrigin(): ");
-  MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(), origin),  "Testing correctness of changed origin via GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(): ");
+  MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetPlaneGeometry(0)->GetOrigin(), origin),  "Testing correctness of changed origin via GetSlicedGeometry()->GetPlaneGeometry(0)->GetOrigin(): ");
 
   //-----------------
   // testing spacing information and methodsunsigned int dim[]={100,100,20};
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correct spacing from Geometry3D!");
 
   mitk::FillVector3D(spacing, 7.0, 0.92, 1.83);
   imgMem->SetSpacing(spacing);
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correctness of changed spacing via GetGeometry()->GetSpacing(): ");
-  MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(), spacing), "Testing correctness of changed spacing via GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(): ");
+  MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetPlaneGeometry(0)->GetSpacing(), spacing), "Testing correctness of changed spacing via GetSlicedGeometry()->GetPlaneGeometry(0)->GetSpacing(): ");
 
   mitk::Image::Pointer vecImg = mitk::Image::New();
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     vecImg->Initialize( imgMem->GetPixelType(), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/ );
     vecImg->SetImportChannel(const_cast<void*>(imgMemAcc.GetData()), 0, mitk::Image::CopyMemory );
     vecImg->SetImportChannel(const_cast<void*>(imgMemAcc.GetData()), 1, mitk::Image::CopyMemory );
 
     mitk::ImageReadAccessor vecImgAcc(vecImg);
     mitk::ImageReadAccessor vecImgAcc0(vecImg, vecImg->GetChannelData(0));
     mitk::ImageReadAccessor vecImgAcc1(vecImg, vecImg->GetChannelData(1));
 
     MITK_TEST_CONDITION_REQUIRED(vecImgAcc0.GetData() != NULL && vecImgAcc1.GetData() != NULL, "Testing set and return of channel data!");
 
     MITK_TEST_CONDITION_REQUIRED( vecImg->IsValidSlice(0,0,1) , "");
     MITK_TEST_OUTPUT(<< " Testing whether CopyMemory worked");
     MITK_TEST_CONDITION_REQUIRED(imgMemAcc.GetData() != vecImgAcc.GetData(), "");
     MITK_TEST_OUTPUT(<< " Testing destruction after SetImportChannel");
     vecImg = NULL;
     MITK_TEST_CONDITION_REQUIRED(vecImg.IsNull() , "testing destruction!");
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   //-----------------
   MITK_TEST_OUTPUT(<< "Testing initialization via vtkImageData");
   MITK_TEST_OUTPUT(<< " Setting up vtkImageData");
   vtkImageData* vtkimage = vtkImageData::New();
   vtkimage->Initialize();
   vtkimage->SetDimensions( 2, 3, 4);
   double vtkorigin[] =  {-350,-358.203, -1363.5};
   vtkimage->SetOrigin(vtkorigin);
   mitk::Point3D vtkoriginAsMitkPoint;
   mitk::vtk2itk(vtkorigin, vtkoriginAsMitkPoint);
   double vtkspacing[] =  {1.367, 1.367, 2};
   vtkimage->SetSpacing(vtkspacing);
   vtkimage->AllocateScalars(VTK_SHORT,1);
   std::cout<<"[PASSED]"<<std::endl;
 
   MITK_TEST_OUTPUT(<< " Testing mitk::Image::Initialize(vtkImageData*, ...)");
   mitk::Image::Pointer mitkByVtkImage = mitk::Image::New();
   mitkByVtkImage ->Initialize(vtkimage);
   MITK_TEST_CONDITION_REQUIRED(mitkByVtkImage->IsInitialized(), "");
   vtkimage->Delete();
 
   MITK_TEST_OUTPUT(<< " Testing whether spacing has been correctly initialized from vtkImageData");
   mitk::Vector3D spacing2 = mitkByVtkImage->GetGeometry()->GetSpacing();
   mitk::Vector3D vtkspacingAsMitkVector;
   mitk::vtk2itk(vtkspacing, vtkspacingAsMitkVector);
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(spacing2,vtkspacingAsMitkVector), "");
 
   MITK_TEST_OUTPUT(<< " Testing whether GetSlicedGeometry(0)->GetOrigin() has been correctly initialized from vtkImageData");
   mitk::Point3D origin2 = mitkByVtkImage->GetSlicedGeometry(0)->GetOrigin();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
 
   MITK_TEST_OUTPUT(<< " Testing whether GetGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
   origin2 = mitkByVtkImage->GetGeometry()->GetOrigin();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
 
   // TODO test the following initializers on channel-incorporation
   //  void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions, unsigned int channels)
   //  void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry2d, bool flipped, unsigned int channels, int tDim )
   //  void mitk::Image::Initialize(const mitk::Image* image)
   //  void mitk::Image::Initialize(const mitkIpPicDescriptor* pic, int channels, int tDim, int sDim)
 
   //mitk::Image::Pointer vecImg = mitk::Image::New();
   //vecImg->Initialize(PixelType(typeid(float), 6, itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
   //vecImg->Initialize(PixelType(typeid(itk::Vector<float,6>)), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
 
   // testing access by index coordinates and by world coordinates
 
   MITK_TEST_CONDITION_REQUIRED(argc == 2, "Check if test image is accessible!");
   const std::string filename = std::string(argv[1]);
   mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
   try
   {
     imageReader->SetFileName(filename);
     imageReader->Update();
   }
   catch(...) {
     MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
     return 0;
   }
 
   mitk::Image::Pointer image = imageReader->GetOutput();
   mitk::Point3D point;
   mitk::ScalarType value = -1.;
 
   mitkPixelTypeMultiplex3(TestRandomPixelAccess,image->GetImageDescriptor()->GetChannelTypeById(0),image,point,value)
 
   {
     // testing the clone method of mitk::Image
     mitk::Image::Pointer cloneImage = image->Clone();
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension() == image->GetDimension(), "Clone (testing dimension)");
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetPixelType() == image->GetPixelType(), "Clone (testing pixel type)");
   // After cloning an image the geometry of both images should be equal too
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetOrigin() == image->GetGeometry()->GetOrigin(), "Clone (testing origin)");
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetSpacing() == image->GetGeometry()->GetSpacing(), "Clone (testing spacing)");
   MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetGeometry()->GetIndexToWorldTransform()->GetMatrix(), image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix()),
     "Clone (testing transformation matrix)");
   MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetTimeGeometry()->GetGeometryForTimeStep(cloneImage->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix(),
     cloneImage->GetTimeGeometry()->GetGeometryForTimeStep(image->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix()), "Clone(testing time sliced geometry)");
 
   for (unsigned int i = 0u; i < cloneImage->GetDimension(); ++i)
   {
     MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension(i) == image->GetDimension(i), "Clone (testing dimension " << i << ")");
   }
   }
   //access via itk
   if(image->GetDimension()> 3)    // CastToItk only works with 3d images so we need to check for 4d images
   {
     mitk::ImageTimeSelector::Pointer selector = mitk::ImageTimeSelector::New();
     selector->SetTimeNr(0);
     selector->SetInput(image);
     selector->Update();
     image = selector->GetOutput();
   }
 
   if(image->GetDimension()==3)
   {
     typedef itk::Image<double,3> ItkFloatImage3D;
     ItkFloatImage3D::Pointer itkimage;
     try
     {
     mitk::CastToItkImage(image, itkimage);
     MITK_TEST_CONDITION_REQUIRED(itkimage.IsNotNull(), "Test conversion to itk::Image!");
     }
     catch (std::exception& e)
     {
       MITK_INFO << e.what();
     }
     mitk::Point3D itkPhysicalPoint;
     image->GetGeometry()->WorldToItkPhysicalPoint(point, itkPhysicalPoint);
     MITK_INFO << "ITKPoint " << itkPhysicalPoint[0] << " "<< itkPhysicalPoint[1] << " "<< itkPhysicalPoint[2] << "";
 
     mitk::Point3D backTransformedPoint;
     image->GetGeometry()->ItkPhysicalPointToWorld(itkPhysicalPoint, backTransformedPoint);
 
     MITK_TEST_CONDITION_REQUIRED( mitk::Equal(point,backTransformedPoint), "Testing world->itk-physical->world consistency");
 
     itk::Index<3> idx;
     bool status = itkimage->TransformPhysicalPointToIndex(itkPhysicalPoint, idx);
 
     MITK_INFO << "ITK Index " << idx[0] << " "<< idx[1] << " "<< idx[2] << "";
 
     if(status && value != -1.)
     {
       float valByItk = itkimage->GetPixel(idx);
       MITK_TEST_CONDITION_REQUIRED( mitk::Equal(valByItk, value), "Compare value of pixel returned by mitk in comparison to itk");
     }
     else
     {
       MITK_WARN<< "Index is out buffered region!";
     }
   }
   else
   {
     MITK_INFO << "Image does not contain three dimensions, some test cases are skipped!";
   }
 
   // clone generated 3D image with one slice in z direction (cf. bug 11058)
   unsigned int* threeDdim = new unsigned int[3];
   threeDdim[0] = 100;
   threeDdim[1] = 200;
   threeDdim[2] = 1;
   mitk::Image::Pointer threeDImage = mitk::Image::New();
   threeDImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, threeDdim);
   mitk::Image::Pointer cloneThreeDImage = threeDImage->Clone();
   // check that the clone image has the same dimensionality as the source image
   MITK_TEST_CONDITION_REQUIRED( cloneThreeDImage->GetDimension() == 3, "Testing if the clone image initializes with 3D!");
 
   MITK_TEST_CONDITION_REQUIRED( ImageVtkDataReferenceCheck(argv[1]), "Checking reference count of Image after using GetVtkImageData()");
 
   MITK_TEST_END();
 }
diff --git a/Core/Code/Testing/mitkImageWriterTest.cpp b/Core/Code/Testing/mitkImageWriterTest.cpp
index d30f1c9f24..7c798c0175 100644
--- a/Core/Code/Testing/mitkImageWriterTest.cpp
+++ b/Core/Code/Testing/mitkImageWriterTest.cpp
@@ -1,287 +1,287 @@
 /*===================================================================
 
 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 "mitkImageWriter.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkTestingMacros.h"
 #include "mitkItkImageFileReader.h"
 #include "mitkException.h"
 
 #include <mitkExtractSliceFilter.h>
 #include "mitkIOUtil.h"
 
 #include <iostream>
 #include <fstream>
 
 #ifdef WIN32
 #include "process.h"
 #else
 #include <unistd.h>
 #endif
 
 std::string AppendExtension(const std::string &filename, const char *extension)
 {
   std::string new_filename = filename;
 
   new_filename += extension;
   return new_filename;
 }
 
 bool CompareImageMetaData( mitk::Image::Pointer image, mitk::Image::Pointer reference, bool checkPixelType = true )
 {
   // switch to AreIdentical() methods as soon as Bug 11925 (Basic comparison operators) is fixed
 
   if( image->GetDimension() != reference->GetDimension() )
   {
     MITK_ERROR << "The image dimension differs: IN (" << image->GetDimension() << ") REF(" << reference->GetDimension() << ")";
     return false;
   }
 
   // pixel type
   if( checkPixelType &&
       ( image->GetPixelType() != reference->GetPixelType()
       && image->GetPixelType().GetBitsPerComponent() != reference->GetPixelType().GetBitsPerComponent() ) )
   {
     MITK_ERROR << "Pixeltype differs ( image=" << image->GetPixelType().GetPixelTypeAsString() << "[" << image->GetPixelType().GetBitsPerComponent() << "]" << " reference=" << reference->GetPixelType().GetPixelTypeAsString() << "[" << reference->GetPixelType().GetBitsPerComponent() << "]" << " )";
     return false;
   }
 
   return true;
 }
 
 
 /*
 Test writing picture formats like *.bmp, *.png, *.tiff or *.jpg
 NOTE: Saving as picture format must ignore PixelType comparison - not all bits per components are supported (see specification of the format)
 */
 void TestPictureWriting(mitk::Image* image, const std::string& filename, const std::string& extension)
 {
    mitk::ImageWriter::Pointer myImageWriter = mitk::ImageWriter::New();
    myImageWriter->SetFileName(AppendExtension(filename, extension.c_str()) );
    myImageWriter->SetFilePrefix("pref");
    myImageWriter->SetFilePattern("pattern");
    myImageWriter->SetInput(image);
 
 
    mitk::Image::Pointer singleSliceImage = NULL;
   if( image->GetDimension() == 3 )
   {
     mitk::ExtractSliceFilter::Pointer extractFilter = mitk::ExtractSliceFilter::New();
     extractFilter->SetInput( image );
-    extractFilter->SetWorldGeometry( image->GetSlicedGeometry()->GetGeometry2D(0) );
+    extractFilter->SetWorldGeometry( image->GetSlicedGeometry()->GetPlaneGeometry(0) );
 
     extractFilter->Update();
     singleSliceImage = extractFilter->GetOutput();
 
     // test 3D writing in format supporting only 2D
     myImageWriter->Update();
 
     // test images
     unsigned int foundImagesCount = 0;
 
     //if the image only contains one sinlge slice the itkImageSeriesWriter won't add a number like filename.XX.extension
     if(image->GetDimension(2) == 1)
     {
       std::stringstream series_filenames;
         series_filenames << filename << extension;
         mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( series_filenames.str() );
         if( compareImage.IsNotNull() )
         {
           foundImagesCount++;
           MITK_TEST_CONDITION(CompareImageMetaData( singleSliceImage, compareImage, false ), "Image meta data unchanged after writing and loading again. "); //ignore bits per component
         }
         remove( series_filenames.str().c_str() );
     }
     else //test the whole slice stack
     {
       for( unsigned int i=0; i< image->GetDimension(2); i++)
       {
         std::stringstream series_filenames;
         series_filenames << filename << "." << i+1 << extension;
         mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( series_filenames.str() );
         if( compareImage.IsNotNull() )
         {
           foundImagesCount++;
           MITK_TEST_CONDITION(CompareImageMetaData( singleSliceImage, compareImage, false ), "Image meta data unchanged after writing and loading again. "); //ignore bits per component
         }
         remove( series_filenames.str().c_str() );
       }
     }
     MITK_TEST_CONDITION( foundImagesCount == image->GetDimension(2), "All 2D-Slices of a 3D image were stored correctly.");
   }
   else if( image->GetDimension() == 2 )
   {
     singleSliceImage = image;
   }
 
   // test 2D writing
   if( singleSliceImage.IsNotNull() )
   {
     try
     {
       myImageWriter->SetInput( singleSliceImage );
       myImageWriter->Update();
 
       mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( AppendExtension(filename, extension.c_str()).c_str());
       MITK_TEST_CONDITION_REQUIRED( compareImage.IsNotNull(), "Image stored was succesfully loaded again");
 
       MITK_TEST_CONDITION_REQUIRED( CompareImageMetaData(singleSliceImage, compareImage, false ), "Image meta data unchanged after writing and loading again. ");//ignore bits per component
       remove(AppendExtension(filename, extension.c_str()).c_str());
     }
     catch(itk::ExceptionObject &e)
     {
       MITK_TEST_FAILED_MSG(<< "Exception during file writing for ." << extension << ": " << e.what() );
     }
 
   }
 
 }
 
 /**
 *  test for "ImageWriter".
 *
 *  argc and argv are the command line parameters which were passed to
 *  the ADD_TEST command in the CMakeLists.txt file. For the automatic
 *  tests, argv is either empty for the simple tests or contains the filename
 *  of a test image for the image tests (see CMakeLists.txt).
 */
 int mitkImageWriterTest(int  argc , char* argv[])
 {
   // always start with this!
   MITK_TEST_BEGIN("ImageWriter")
 
   // let's create an object of our class
   mitk::ImageWriter::Pointer myImageWriter = mitk::ImageWriter::New();
 
   // first test: did this work?
   // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
   // it makes no sense to continue without an object.
   MITK_TEST_CONDITION_REQUIRED(myImageWriter.IsNotNull(),"Testing instantiation")
 
   // write your own tests here and use the macros from mitkTestingMacros.h !!!
   // do not write to std::cout and do not return from this function yourself!
 
   // load image
   MITK_TEST_CONDITION_REQUIRED(argc > 1, "File to load has been specified");
 
 
   mitk::Image::Pointer image = NULL;
 
   try
   {
     MITK_TEST_OUTPUT(<< "Loading file: " << argv[1]);
     image = mitk::IOUtil::LoadImage( argv[1] );
   }
   catch (itk::ExceptionObject & ex)
   {
     MITK_TEST_FAILED_MSG(<< "Exception during file loading: " << ex.GetDescription());
   }
 
 
   MITK_TEST_CONDITION_REQUIRED(image.IsNotNull(),"loaded image not NULL")
   std::stringstream filename_stream;
 
 #ifdef WIN32
   filename_stream << "test" << _getpid();
 #else
   filename_stream << "test" << getpid();
 #endif
 
 
   std::string filename = filename_stream.str();
   std::cout << filename << std::endl;
 
   // test set/get methods
   myImageWriter->SetInput(image);
   MITK_TEST_CONDITION_REQUIRED(myImageWriter->GetInput()==image,"test Set/GetInput()");
   myImageWriter->SetFileName(filename);
   MITK_TEST_CONDITION_REQUIRED(!strcmp(myImageWriter->GetFileName(),filename.c_str()),"test Set/GetFileName()");
   myImageWriter->SetFilePrefix("pref");
   MITK_TEST_CONDITION_REQUIRED(!strcmp(myImageWriter->GetFilePrefix(),"pref"),"test Set/GetFilePrefix()");
   myImageWriter->SetFilePattern("pattern");
   MITK_TEST_CONDITION_REQUIRED(!strcmp(myImageWriter->GetFilePattern(),"pattern"),"test Set/GetFilePattern()");
 
   // write ITK .mhd image (2D and 3D only)
   if( image->GetDimension() <= 3 )
   {
     try
     {
       myImageWriter->SetExtension(".mhd");
       myImageWriter->Update();
 
       mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( AppendExtension(filename, ".mhd").c_str() );
       MITK_TEST_CONDITION_REQUIRED( compareImage.IsNotNull(), "Image stored in MHD format was succesfully loaded again! ");
 
       std::string rawExtension = ".raw";
       std::fstream rawPartIn;
       rawPartIn.open(AppendExtension(filename, ".raw").c_str());
       if( !rawPartIn.is_open() )
       {
         rawExtension = ".zraw";
         rawPartIn.open(AppendExtension(filename, ".zraw").c_str());
       }
 
       MITK_TEST_CONDITION_REQUIRED(rawPartIn.is_open(),"Write .raw file");
       rawPartIn.close();
 
       // delete
       remove(AppendExtension(filename, ".mhd").c_str());
       remove(AppendExtension(filename, rawExtension.c_str()).c_str());
     }
     catch (...)
     {
       MITK_TEST_FAILED_MSG(<< "Exception during .mhd file writing");
     }
   }
 
   //testing more component image writing as nrrd files
   try
   {
     myImageWriter->SetExtension(".nrrd");
     myImageWriter->Update();
     std::fstream fin;
     mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage(AppendExtension(filename, ".nrrd").c_str());
     MITK_TEST_CONDITION_REQUIRED(compareImage.IsNotNull(), "Image stored in NRRD format was succesfully loaded again");
     fin.close();
     remove(AppendExtension(filename, ".nrrd").c_str());
   }
   catch(...)
   {
     MITK_TEST_FAILED_MSG(<< "Exception during .nrrd file writing");
   }
 
   TestPictureWriting(image, filename, ".png");
   TestPictureWriting(image, filename, ".jpg");
   TestPictureWriting(image, filename, ".tiff");
   TestPictureWriting(image, filename, ".bmp");
 
   // test for exception handling
   try
   {
     MITK_TEST_FOR_EXCEPTION_BEGIN(itk::ExceptionObject)
     myImageWriter->SetInput(image);
     myImageWriter->SetFileName("/usr/bin");
     myImageWriter->Update();
     MITK_TEST_FOR_EXCEPTION_END(itk::ExceptionObject)
   }
   catch(...) {
     //this means that a wrong exception (i.e. no itk:Exception) has been thrown
     MITK_TEST_FAILED_MSG(<< "Wrong exception (i.e. no itk:Exception) caught during write");
   }
 
   // always end with this!
   MITK_TEST_END();
 }
diff --git a/Core/Code/Testing/mitkPlaneGeometryTest.cpp b/Core/Code/Testing/mitkPlaneGeometryTest.cpp
index f418cfd2de..e5149f574c 100644
--- a/Core/Code/Testing/mitkPlaneGeometryTest.cpp
+++ b/Core/Code/Testing/mitkPlaneGeometryTest.cpp
@@ -1,1025 +1,1141 @@
 /*===================================================================
 
 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 "mitkPlaneGeometry.h"
 #include "mitkRotationOperation.h"
 #include "mitkInteractionConst.h"
 #include "mitkLine.h"
 
 #include "mitkTestingMacros.h"
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.txx>
 
 #include <fstream>
 #include <iomanip>
 
 static const mitk::ScalarType testEps = 1E-9; // the epsilon used in this test == at least float precision.
 
 int mappingTests2D(const mitk::PlaneGeometry* planegeometry, const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::Point3D& origin, const mitk::Vector3D& right, const mitk::Vector3D& bottom)
 {
 
   std::cout << "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected: ";
   mitk::Point2D pt2d_mm;
   mitk::Point3D pt3d_mm, expected_pt3d_mm;
   pt2d_mm[0] = widthInMM/2.3; pt2d_mm[1] = heightInMM/2.5;
   expected_pt3d_mm = origin+right*(pt2d_mm[0]/right.GetNorm())+bottom*(pt2d_mm[1]/bottom.GetNorm());
   planegeometry->Map(pt2d_mm, pt3d_mm);
   if(mitk::Equal(pt3d_mm, expected_pt3d_mm, testEps) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected: ";
   mitk::Point2D testpt2d_mm;
   planegeometry->Map(pt3d_mm, testpt2d_mm);
   std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
   std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
   std::cout << std::setprecision(12) << "10*mitk::eps " << 10*mitk::eps << std::endl;
   //This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
   if(mitk::Equal(pt2d_mm, testpt2d_mm, 10*mitk::eps) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ";
   mitk::Point2D pt2d_units;
   pt2d_units[0] = width/2.0;     pt2d_units[1] = height/2.0;
   pt2d_mm[0]    = widthInMM/2.0; pt2d_mm[1]    = heightInMM/2.0;
   planegeometry->IndexToWorld(pt2d_units, testpt2d_mm);
 
   std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
   std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
   std::cout << std::setprecision(12) << "10*mitk::eps " << 10*mitk::eps << std::endl;
   //This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
   if(mitk::Equal(pt2d_mm, testpt2d_mm, 10*mitk::eps) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected: ";
   mitk::Point2D testpt2d_units;
   planegeometry->WorldToIndex(pt2d_mm, testpt2d_units);
 
   std::cout << std::setprecision(12) << "Expected pt2d_units " << pt2d_units << std::endl;
   std::cout << std::setprecision(12) << "Result testpt2d_units " << testpt2d_units << std::endl;
   std::cout << std::setprecision(12) << "10*mitk::eps " << 10*mitk::eps << std::endl;
   //This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
   if(mitk::Equal(pt2d_units, testpt2d_units, 10*mitk::eps) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   return EXIT_SUCCESS;
 }
 
 int TestCase1210()
 {
   mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
 
   mitk::Point3D origin;
   mitk::Vector3D right, down, spacing;
 
   mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
   mitk::FillVector3D(right,
       1.015625, 1.015625, 1.1999969482421875
       );
 
   mitk::FillVector3D(down,
       1.4012984643248170709237295832899161312802619418765e-45, 0, 0
       );
   mitk::FillVector3D(spacing,
       0, 1.4713633875410579244699160624544119378442750389703e-43, 9.2806360452222355258639080851310540729807238879469e-32
       );
 
   std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
   planegeometry->InitializeStandardPlane(right, down, &spacing);
 /*
   std::cout << "Testing width, height and thickness (in units): ";
   if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
      (mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
      (mitk::Equal(planegeometry->GetExtent(2),1)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm): ";
   if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
 */
   std::cout<<"[PASSED]"<<std::endl;
 
   return EXIT_SUCCESS;
 }
 
 
 
 /**
  * @brief This method tests method IntersectionPoint
  *
  * See also bug #7151. (ref 2 this test: iggy)
  * This test was written due to incorrect calculation of the intersection point
  * between a given line and plane. This only occured when the pointdistance of
  * the line was less than 1.
  * Test Behavour:
  * ==============
  * we have a given line and a given plane.
  * we let the line intersect the plane.
  * when testing several positions on the line the resulting intersection point must be the same
  * we test a position where the distance between the correspoinding points is < 0 and another position where the distance is > 0.
  *
  */
 int TestIntersectionPoint()
 {
     //init plane with its parameter
     mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
 
     mitk::Point3D origin;
     origin[0] = 0.0;
     origin[1] = 2.0;
     origin[2] = 0.0;
 
     mitk::Vector3D normal;
     normal[0] = 0.0;
     normal[1] = 1.0;
     normal[2] = 0.0;
 
     myPlaneGeometry->InitializePlane(origin,normal);
 
     //generate points and line for intersection testing
     //point distance of given line > 1
     mitk::Point3D pointP1;
     pointP1[0] = 2.0;
     pointP1[1] = 1.0;
     pointP1[2] = 0.0;
 
     mitk::Point3D pointP2;
     pointP2[0] = 2.0;
     pointP2[1] = 4.0;
     pointP2[2] = 0.0;
 
     mitk::Vector3D lineDirection;
     lineDirection[0] = pointP2[0] - pointP1[0];
     lineDirection[1] = pointP2[1] - pointP1[1];
     lineDirection[2] = pointP2[2] - pointP1[2];
 
     mitk::Line3D xingline( pointP1, lineDirection );
     mitk::Point3D calcXingPoint;
     myPlaneGeometry->IntersectionPoint(xingline, calcXingPoint);
 
     //point distance of given line < 1
     mitk::Point3D pointP3;
     pointP3[0] = 2.0;
     pointP3[1] = 2.2;
     pointP3[2] = 0.0;
 
     mitk::Point3D pointP4;
     pointP4[0] = 2.0;
     pointP4[1] = 1.7;
     pointP4[2] = 0.0;
 
     mitk::Vector3D lineDirection2;
     lineDirection2[0] = pointP4[0] - pointP3[0];
     lineDirection2[1] = pointP4[1] - pointP3[1];
     lineDirection2[2] = pointP4[2] - pointP3[2];
 
     mitk::Line3D xingline2( pointP3, lineDirection2 );
     mitk::Point3D calcXingPoint2;
     myPlaneGeometry->IntersectionPoint( xingline2, calcXingPoint2 );
 
     //intersection points must be the same
     if (calcXingPoint == calcXingPoint2) {
         return EXIT_SUCCESS;
 
     } else {
         return EXIT_FAILURE;
     }
 
 }
 
 
 /**
  * @brief This method tests method ProjectPointOntoPlane.
  *
  * See also bug #3409.
  */
 int TestProjectPointOntoPlane()
 {
   mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
 
   //create normal
   mitk::Vector3D normal;
   normal[0] = 0.0;
   normal[1] = 0.0;
   normal[2] = 1.0;
 
   //create origin
   mitk::Point3D origin;
   origin[0] = -27.582859;
   origin[1] = 50;
   origin[2] = 200.27742;
 
   //initialize plane geometry
   myPlaneGeometry->InitializePlane(origin,normal);
 
   //output to descripe the test
   std::cout << "Testing PlaneGeometry according to bug #3409" << std::endl;
   std::cout << "Our normal is: " << normal << std::endl;
   std::cout << "So ALL projected points should have exactly the same z-value!" << std::endl;
 
   //create a number of points
   mitk::Point3D myPoints[5];
   myPoints[0][0] = -27.582859;
   myPoints[0][1] = 50.00;
   myPoints[0][2] = 200.27742;
 
   myPoints[1][0] = -26.58662;
   myPoints[1][1] = 50.00;
   myPoints[1][2] = 200.19026;
 
   myPoints[2][0] = -26.58662;
   myPoints[2][1] = 50.00;
   myPoints[2][2] = 200.33124;
 
   myPoints[3][0] = 104.58662;
   myPoints[3][1] = 452.12313;
   myPoints[3][2] = 866.41236;
 
   myPoints[4][0] = -207.58662;
   myPoints[4][1] = 312.00;
   myPoints[4][2] = -300.12346;
 
   //project points onto plane
   mitk::Point3D myProjectedPoints[5];
   for ( unsigned int i = 0; i < 5; ++i )
   {
     myProjectedPoints[i] = myPlaneGeometry->ProjectPointOntoPlane( myPoints[i] );
   }
 
   //compare z-values with z-value of plane (should be equal)
   bool allPointsOnPlane = true;
   for ( unsigned int i = 0; i < 5; ++i )
   {
     if ( fabs(myProjectedPoints[i][2] - origin[2]) > mitk::sqrteps )
     {
       allPointsOnPlane = false;
     }
   }
   if (!allPointsOnPlane)
     {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
     }
   else
     {
     std::cout<<"[PASSED]"<<std::endl;
     return EXIT_SUCCESS;
     }
 }
 
+mitk::PlaneGeometry::Pointer  createPlaneGeometry()
+{
+   mitk::Vector3D mySpacing;
+   mySpacing[0] = 31;
+   mySpacing[1] = 0.1;
+   mySpacing[2] = 5.4;
+   mitk::Point3D myOrigin;
+   myOrigin[0] = 8;
+   myOrigin[1] = 9;
+   myOrigin[2] = 10;
+   mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
+   itk::Matrix<mitk::ScalarType, 3,3> transMatrix;
+   transMatrix.Fill(0);
+   transMatrix[0][0] = 1;
+   transMatrix[1][1] = 2;
+   transMatrix[2][2] = 4;
+
+   myTransform->SetMatrix(transMatrix);
+
+   mitk::PlaneGeometry::Pointer geometry2D = mitk::PlaneGeometry::New();
+   geometry2D->SetIndexToWorldTransform(myTransform);
+   geometry2D->SetSpacing(mySpacing);
+   geometry2D->SetOrigin(myOrigin);
+   return geometry2D;
+}
+
+int testPlaneGeometryCloning()
+{
+  mitk::PlaneGeometry::Pointer geometry2D = createPlaneGeometry();
+
+  try
+  {
+    mitk::PlaneGeometry::Pointer clone = geometry2D->Clone();
+    itk::Matrix<mitk::ScalarType,3,3> matrix = clone->GetIndexToWorldTransform()->GetMatrix();
+    MITK_TEST_CONDITION(matrix[0][0] == 31, "Test if matrix element exists...");
+
+    double origin = geometry2D->GetOrigin()[0];
+    MITK_TEST_CONDITION(mitk::Equal(origin, 8),"First Point of origin as expected...");
+
+    double spacing = geometry2D->GetSpacing()[0];
+    MITK_TEST_CONDITION(mitk::Equal(spacing, 31),"First Point of spacing as expected...");
+  }
+  catch (...)
+  {
+    MITK_TEST_CONDITION(false, "Error during access on a member of cloned geometry");
+  }
+   // direction [row] [coloum]
+   MITK_TEST_OUTPUT( << "Casting a rotated 2D ITK Image to a MITK Image and check if Geometry is still same" );
+
+  return EXIT_SUCCESS;
+}
+
+bool compareMatrix(itk::Matrix<mitk::ScalarType, 3,3> left, itk::Matrix<mitk::ScalarType, 3,3> right)
+{
+  bool equal = true;
+  for (int i = 0; i < 3; ++i)
+    for (int j = 0; j < 3; ++j)
+      equal &= mitk::Equal(left[i][j], right[i][j]);
+  return equal;
+}
+
+int testPlaneGeometryInitializeOrder()
+{
+   mitk::Vector3D mySpacing;
+   mySpacing[0] = 31;
+   mySpacing[1] = 0.1;
+   mySpacing[2] = 5.4;
+   mitk::Point3D myOrigin;
+   myOrigin[0] = 8;
+   myOrigin[1] = 9;
+   myOrigin[2] = 10;
+   mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
+   itk::Matrix<mitk::ScalarType, 3,3> transMatrix;
+   transMatrix.Fill(0);
+   transMatrix[0][0] = 1;
+   transMatrix[1][1] = 2;
+   transMatrix[2][2] = 4;
+
+   myTransform->SetMatrix(transMatrix);
+
+   mitk::PlaneGeometry::Pointer geometry2D1 = mitk::PlaneGeometry::New();
+   geometry2D1->SetIndexToWorldTransform(myTransform);
+   geometry2D1->SetSpacing(mySpacing);
+   geometry2D1->SetOrigin(myOrigin);
+
+   mitk::PlaneGeometry::Pointer geometry2D2 = mitk::PlaneGeometry::New();
+   geometry2D2->SetSpacing(mySpacing);
+   geometry2D2->SetOrigin(myOrigin);
+   geometry2D2->SetIndexToWorldTransform(myTransform);
+
+   mitk::PlaneGeometry::Pointer geometry2D3 = mitk::PlaneGeometry::New();
+   geometry2D3->SetIndexToWorldTransform(myTransform);
+   geometry2D3->SetSpacing(mySpacing);
+   geometry2D3->SetOrigin(myOrigin);
+   geometry2D3->SetIndexToWorldTransform(myTransform);
+
+   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetOrigin(), geometry2D2->GetOrigin()),"Origin of Geometry 1 match those of Geometry 2.");
+   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetOrigin(), geometry2D3->GetOrigin()),"Origin of Geometry 1 match those of Geometry 3.");
+   MITK_TEST_CONDITION(mitk::Equal(geometry2D2->GetOrigin(), geometry2D3->GetOrigin()),"Origin of Geometry 2 match those of Geometry 3.");
+
+   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetSpacing(), geometry2D2->GetSpacing()),"Spacing of Geometry 1 match those of Geometry 2.");
+   MITK_TEST_CONDITION(mitk::Equal(geometry2D1->GetSpacing(), geometry2D3->GetSpacing()),"Spacing of Geometry 1 match those of Geometry 3.");
+   MITK_TEST_CONDITION(mitk::Equal(geometry2D2->GetSpacing(), geometry2D3->GetSpacing()),"Spacing of Geometry 2 match those of Geometry 3.");
+
+   MITK_TEST_CONDITION(compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(), geometry2D2->GetIndexToWorldTransform()->GetMatrix()),"Transformation of Geometry 1 match those of Geometry 2.");
+   MITK_TEST_CONDITION(compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(), geometry2D3->GetIndexToWorldTransform()->GetMatrix()),"Transformation of Geometry 1 match those of Geometry 3.");
+   MITK_TEST_CONDITION(compareMatrix(geometry2D2->GetIndexToWorldTransform()->GetMatrix(), geometry2D3->GetIndexToWorldTransform()->GetMatrix()),"Transformation of Geometry 2 match those of Geometry 3.");
+   return EXIT_SUCCESS;
+}
+
 int mitkPlaneGeometryTest(int /*argc*/, char* /*argv*/[])
 {
   int result;
 
   /*
   // the following can be used to reproduce a bug in ITK matrix inversion
   // which was found while investigating bug #1210.
   result = TestCase1210();
   if(result!=EXIT_SUCCESS)
     return result;
   */
 
   mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
 
   mitk::Point3D origin;
   mitk::Vector3D right, bottom, normal;
   mitk::ScalarType width, height;
   mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
 
   width  = 100;    widthInMM  = width;
   height = 200;    heightInMM = height;
   thicknessInMM = 1.0;
   mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
   mitk::FillVector3D(right,  widthInMM,          0, 0);
   mitk::FillVector3D(bottom,         0, heightInMM, 0);
   mitk::FillVector3D(normal,         0,          0, thicknessInMM);
 
   std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
   planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector());
 
   std::cout << "Testing width, height and thickness (in units): ";
   if((mitk::Equal(planegeometry->GetExtent(0),width, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtent(1),height, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtent(2),1, testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm): ";
   if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM, testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector(): ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
 
   std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = {1.0, 1.0, 1.5}): "<<std::endl;
   mitk::Vector3D spacing;
   thicknessInMM = 1.5;
   normal.Normalize(); normal *= thicknessInMM;
   mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
   planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
 
   std::cout << "Testing width, height and thickness (in units): ";
   if((mitk::Equal(planegeometry->GetExtent(0),width, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtent(1),height, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtent(2),1, testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm): ";
   if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM, testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector(): ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
 
   std::cout << "Testing SetExtentInMM(2, ...), querying by GetExtentInMM(2): ";
   thicknessInMM = 3.5;
   normal.Normalize(); normal *= thicknessInMM;
   planegeometry->SetExtentInMM(2, thicknessInMM);
   if(mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing SetExtentInMM(2, ...), querying by GetAxisVector(2) and comparing to normal: ";
   if(mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing SetOrigin: ";
   planegeometry->SetOrigin(origin);
   if(mitk::Equal(planegeometry->GetOrigin(), origin, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() after SetOrigin: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
 
   std::cout << "Changing the IndexToWorldTransform to a rotated version by SetIndexToWorldTransform() (keep origin): "<<std::endl;
   mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
   mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
   vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
   mitk::VnlVector axis(3);
   mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize();
   vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
   vnlmatrix = rotation.rotation_matrix_transpose()*vnlmatrix;
   mitk::Matrix3D matrix;
   matrix = vnlmatrix;
   transform->SetMatrix(matrix);
   transform->SetOffset(planegeometry->GetIndexToWorldTransform()->GetOffset());
 
   right.SetVnlVector( rotation.rotation_matrix_transpose()*right.GetVnlVector() );
   bottom.SetVnlVector(rotation.rotation_matrix_transpose()*bottom.GetVnlVector());
   normal.SetVnlVector(rotation.rotation_matrix_transpose()*normal.GetVnlVector());
   planegeometry->SetIndexToWorldTransform(transform);
 
   //The origin changed,because m_Origin=m_IndexToWorldTransform->GetOffset()+GetAxisVector(2)*0.5
   //and the AxisVector changes due to the rotation. In other words: the rotation was done around
   //the corner of the box, not around the planes origin. Now change it to a rotation around
   //the origin, simply by re-setting the origin to the original one:
   planegeometry->SetOrigin(origin);
   mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
 
   std::cout << "Testing whether SetIndexToWorldTransform kept origin: ";
   if(mitk::Equal(planegeometry->GetOrigin(), origin, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
 
   MITK_TEST_OUTPUT( << "Testing consistancy of index and world coordinates. ");
   mitk::Point2D point; point[0] = 4; point[1] = 3;
   mitk::Point2D dummy;
   planegeometry->WorldToIndex(point, dummy);
   planegeometry->IndexToWorld(dummy, dummy);
   MITK_TEST_CONDITION_REQUIRED(dummy == point, "");
 
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of rotated version: ";
   if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM, testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of rotated version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(),planegeometry->GetExtentInMM(0), testEps)==false) ||
      (mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(),planegeometry->GetExtentInMM(1), testEps)==false) ||
      (mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(),planegeometry->GetExtentInMM(2), testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
   std::cout << "Testing SetSizeInUnits() of rotated version: "<<std::endl;
   width  *= 2;
   height *= 3;
   planegeometry->SetSizeInUnits(width, height);
 
   std::cout << "Testing width, height and thickness (in units): ";
   if((mitk::Equal(planegeometry->GetExtent(0),width, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtent(1),height, testEps)==false) ||
      (mitk::Equal(planegeometry->GetExtent(2),1, testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of version with changed size in units: ";
   if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of version with changed size in units: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(),planegeometry->GetExtentInMM(0), testEps)==false) ||
      (mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(),planegeometry->GetExtentInMM(1), testEps)==false) ||
      (mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(),planegeometry->GetExtentInMM(2), testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
 
   std::cout << "Testing Clone(): ";
   mitk::PlaneGeometry::Pointer clonedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(planegeometry->Clone().GetPointer());
   if((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount()!=1))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing origin of cloned version: ";
   if(mitk::Equal(clonedplanegeometry->GetOrigin(), origin, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in units) of cloned version: ";
   if((mitk::Equal(clonedplanegeometry->GetExtent(0),width, testEps)==false) ||
      (mitk::Equal(clonedplanegeometry->GetExtent(1),height, testEps)==false) ||
      (mitk::Equal(clonedplanegeometry->GetExtent(2),1, testEps)==false)
     )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of cloned version: ";
   if(!mitk::Equal(clonedplanegeometry->GetExtentInMM(0), widthInMM, testEps) || !mitk::Equal(clonedplanegeometry->GetExtentInMM(1), heightInMM, testEps) || !mitk::Equal(clonedplanegeometry->GetExtentInMM(2), thicknessInMM, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of cloned version: ";
   if((mitk::Equal(clonedplanegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(clonedplanegeometry->GetAxisVector(1), bottom, testEps)==false) || (mitk::Equal(clonedplanegeometry->GetAxisVector(2), normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(clonedplanegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
   // Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
   std::cout << "Testing Clone(): ";
   mitk::PlaneGeometry::Pointer clonedplanegeometry2 = dynamic_cast<mitk::PlaneGeometry*>(planegeometry->Clone().GetPointer());
   if((clonedplanegeometry2.IsNull()) || (clonedplanegeometry2->GetReferenceCount()!=1))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout << "Testing if cloned and original version are at the same place: ";
   if(mitk::Equal(clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()), true) ==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing if the origin is on the plane: ";
   if(mitk::Equal(clonedplanegeometry2->IsOnPlane(origin), true)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   mitk::VnlVector newaxis(3);
   mitk::FillVector3D(newaxis, 1.0, 1.0, 1.0); newaxis.normalize();
   vnl_quaternion<mitk::ScalarType> rotation2(newaxis, 0.0);
 
   mitk::Vector3D clonednormal = clonedplanegeometry2->GetNormal();
   mitk::Point3D clonedorigin = clonedplanegeometry2->GetOrigin();
 
   mitk::RotationOperation* planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), 180.0 );
 
   clonedplanegeometry2->ExecuteOperation( planerot );
 
   std::cout << "Testing whether the flipped plane is still the original plane: ";
   if( mitk::Equal( clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()), true )==false )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   clonedorigin += clonednormal;
   clonedplanegeometry2->SetOrigin( clonedorigin );
 
   std::cout << "Testing if the translated (cloned, flipped) plane is parallel to its origin plane: ";
   if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), true )==false )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
   delete planerot;
 
   planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), 0.5 );
   clonedplanegeometry2->ExecuteOperation( planerot );
 
   std::cout << "Testing if a non-paralell plane gets recognized as not paralell  [rotation +0.5 degree] : ";
   if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), false )==false )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   delete planerot;
 
   planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), -1.0 );
   clonedplanegeometry2->ExecuteOperation( planerot );
 
   std::cout << "Testing if a non-paralell plane gets recognized as not paralell  [rotation -0.5 degree] : ";
   if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), false )==false )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   delete planerot;
 
   planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), 360.5 );
   clonedplanegeometry2->ExecuteOperation( planerot );
 
   std::cout << "Testing if a non-paralell plane gets recognized as not paralell  [rotation 360 degree] : ";
   if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), true )==false )
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
   std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition = 0, frontside=true): " <<std::endl;
   planegeometry->InitializeStandardPlane(clonedplanegeometry);
 
   std::cout << "Testing origin of axially initialized version: ";
   if(mitk::Equal(planegeometry->GetOrigin(), origin)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetCornerPoint(0) of axially initialized version: ";
   if(mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in units) of axially initialized version (should be same as in mm due to unit spacing, except for thickness, which is always 1): ";
   if(!mitk::Equal(planegeometry->GetExtent(0), width, testEps) || !mitk::Equal(planegeometry->GetExtent(1), height, testEps) || !mitk::Equal(planegeometry->GetExtent(2), 1, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of axially initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of axially initialized version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
 
   mitk::Vector3D newright, newbottom, newnormal;
   mitk::ScalarType newthicknessInMM;
   std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Frontal, zPosition = 0, frontside=true): " <<std::endl;
   planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Frontal);
   newright = right;
   newbottom = normal; newbottom.Normalize();  newbottom *= thicknessInMM;
   newthicknessInMM = heightInMM/height*1.0/*extent in normal direction is 1*/;
   newnormal = -bottom; newnormal.Normalize(); newnormal *= newthicknessInMM;
 
   std::cout << "Testing GetCornerPoint(0) of frontally initialized version: ";
   if(mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
   //ok, corner was fine, so we can dare to believe the origin is ok.
   origin = planegeometry->GetOrigin();
 
   std::cout << "Testing width, height and thickness (in units) of frontally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtent(0), width, testEps) || !mitk::Equal(planegeometry->GetExtent(1), 1, testEps) || !mitk::Equal(planegeometry->GetExtent(2), 1, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of frontally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of frontally initialized version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, width, 1, widthInMM, thicknessInMM, origin, newright, newbottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
 
   std::cout << "Changing plane to in-plane unit spacing using SetSizeInUnits: " <<std::endl;
   planegeometry->SetSizeInUnits(planegeometry->GetExtentInMM(0), planegeometry->GetExtentInMM(1));
 
   std::cout << "Testing origin of unit spaced, frontally initialized version: ";
   if(mitk::Equal(planegeometry->GetOrigin(), origin, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps) || !mitk::Equal(planegeometry->GetExtent(2), 1, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of unit spaced, frontally initialized version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
 
   std::cout << "Changing plane to unit spacing also in normal direction using SetExtentInMM(2, 1.0): " <<std::endl;
   planegeometry->SetExtentInMM(2, 1.0);
   newnormal.Normalize();
 
   std::cout << "Testing origin of unit spaced, frontally initialized version: ";
   if(mitk::Equal(planegeometry->GetOrigin(), origin, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps) || !mitk::Equal(planegeometry->GetExtent(2), 1, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(2), 1.0, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of unit spaced, frontally initialized version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
 
   std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Sagittal, zPosition = 0, frontside=true): " <<std::endl;
   planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Sagittal);
   newright = bottom;
   newthicknessInMM = widthInMM/width*1.0/*extent in normal direction is 1*/;
   newnormal = right; newnormal.Normalize(); newnormal *= newthicknessInMM;
 
   std::cout << "Testing GetCornerPoint(0) of sagitally initialized version: ";
   if(mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
   //ok, corner was fine, so we can dare to believe the origin is ok.
   origin = planegeometry->GetOrigin();
 
   std::cout << "Testing width, height and thickness (in units) of sagitally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtent(0), height, testEps) || !mitk::Equal(planegeometry->GetExtent(1), 1, testEps) || !mitk::Equal(planegeometry->GetExtent(2), 1, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of sagitally initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtentInMM(0), heightInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of sagitally initialized version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, height, 1, heightInMM, thicknessInMM, origin, newright, newbottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
 
   //set origin back to the one of the axial slice:
   origin = clonedplanegeometry->GetOrigin();
   std::cout << "Testing backside initialization: InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition = 0, frontside=false, rotated=true): " <<std::endl;
   planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Axial, 0, false, true);
   mitk::Point3D backsideorigin;
   backsideorigin=origin+clonedplanegeometry->GetAxisVector(1);//+clonedplanegeometry->GetAxisVector(2);
 
   std::cout << "Testing origin of backsidedly, axially initialized version: ";
   if(mitk::Equal(planegeometry->GetOrigin(), backsideorigin, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetCornerPoint(0) of sagitally initialized version: ";
   mitk::Point3D backsidecornerpoint0;
   backsidecornerpoint0 = cornerpoint0+clonedplanegeometry->GetAxisVector(1);//+clonedplanegeometry->GetAxisVector(2);
   if(mitk::Equal(planegeometry->GetCornerPoint(0), backsidecornerpoint0, testEps)==false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in units) of backsidedly, axially initialized version (should be same as in mm due to unit spacing, except for thickness, which is always 1): ";
   if(!mitk::Equal(planegeometry->GetExtent(0), width, testEps) || !mitk::Equal(planegeometry->GetExtent(1), height, testEps) || !mitk::Equal(planegeometry->GetExtent(2), 1, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ";
   if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps) || !mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing GetAxisVector() of backsidedly, axially initialized version: ";
   if((mitk::Equal(planegeometry->GetAxisVector(0), right, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), -bottom, testEps)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), -normal, testEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, backsideorigin, right, -bottom);
   if(result!=EXIT_SUCCESS)
     return result;
 
 
   // test method mitk::PlaneGeometry::ProjectPointOntoPlane()
   // (see also bug #3409)
   result = TestProjectPointOntoPlane();
   if(result!=EXIT_SUCCESS)
     return result;
 
 
   // testing mitk::PlaneGeometry::IntersectionPoint()
   std::cout << std::endl;
   std::cout << "Testing IntersectionPoint using given plane and given line:  ";
     result = TestIntersectionPoint();
     if (result != EXIT_SUCCESS) {
         std::cout << "[FAILED]" << std::endl;
         return result;
     }
 
   std::cout<<"[PASSED]"<<std::endl<<std::endl;
 
+   int result2;
+
+  MITK_TEST_CONDITION_REQUIRED ( (result2 = testPlaneGeometryCloning()) == EXIT_SUCCESS, "");
+
+  // See bug 15990
+  // MITK_TEST_CONDITION_REQUIRED ( (result = testPlaneGeometryInitializeOrder()) == EXIT_SUCCESS, "");
 
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
diff --git a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
index 13f828fc7c..6541f21663 100644
--- a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
+++ b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
@@ -1,572 +1,572 @@
 /*===================================================================
 
 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 "mitkSliceNavigationController.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkRotationOperation.h"
 #include "mitkInteractionConst.h"
 #include "mitkPlanePositionManager.h"
 #include "mitkTestingMacros.h"
 
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 #include "usServiceReference.h"
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.txx>
 
 #include <fstream>
 
 bool operator==(const mitk::Geometry3D & left, const mitk::Geometry3D & right)
 {
    mitk::BoundingBox::BoundsArrayType leftbounds, rightbounds;
    leftbounds =left.GetBounds();
    rightbounds=right.GetBounds();
 
    unsigned int i;
    for(i=0;i<6;++i)
       if(mitk::Equal(leftbounds[i],rightbounds[i])==false) return false;
 
    const mitk::Geometry3D::TransformType::MatrixType & leftmatrix  = left.GetIndexToWorldTransform()->GetMatrix();
    const mitk::Geometry3D::TransformType::MatrixType & rightmatrix = right.GetIndexToWorldTransform()->GetMatrix();
 
    unsigned int j;
    for(i=0;i<3;++i)
    {
       const mitk::Geometry3D::TransformType::MatrixType::ValueType* leftvector  = leftmatrix[i];
       const mitk::Geometry3D::TransformType::MatrixType::ValueType* rightvector = rightmatrix[i];
       for(j=0;j<3;++j)
          if(mitk::Equal(leftvector[i],rightvector[i])==false) return false;
    }
 
    const mitk::Geometry3D::TransformType::OffsetType & leftoffset  = left.GetIndexToWorldTransform()->GetOffset();
    const mitk::Geometry3D::TransformType::OffsetType & rightoffset = right.GetIndexToWorldTransform()->GetOffset();
    for(i=0;i<3;++i)
       if(mitk::Equal(leftoffset[i],rightoffset[i])==false) return false;
 
    return true;
 }
 
 int compareGeometry(const mitk::TimeGeometry & timeGeometry,
                     const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& numSlices,
                     const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::ScalarType& thicknessInMM,
                     const mitk::Point3D& cornerpoint0, const mitk::Vector3D& right, const mitk::Vector3D& bottom, const mitk::Vector3D& normal)
 {
    //Probleme durch umstellung von Time-SlicedGeometry auf  TimeGeometry?
    //Eventuell gibt es keine Entsprechung mehr.
    const mitk::BaseGeometry::Pointer geometry= timeGeometry.GetGeometryForTimeStep(0);
    std::cout << "Testing width, height and thickness (in units): ";
    if((mitk::Equal(geometry->GetExtent(0),width)==false) ||
       (mitk::Equal(geometry->GetExtent(1),height)==false) ||
       (mitk::Equal(geometry->GetExtent(2),numSlices)==false)
       )
    {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing width, height and thickness (in mm): ";
    if((mitk::Equal(geometry->GetExtentInMM(0),widthInMM)==false) ||
       (mitk::Equal(geometry->GetExtentInMM(1),heightInMM)==false) ||
       (mitk::Equal(geometry->GetExtentInMM(2),thicknessInMM)==false)
       )
    {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing GetAxisVector(): ";
    std::cout << "dir=0 ";
    mitk::Vector3D dv;
    dv=right; dv.Normalize(); dv*=widthInMM;
    if((mitk::Equal(geometry->GetAxisVector(0), dv)==false))
    {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]";
    std::cout << ", dir=1 ";
    dv=bottom; dv.Normalize(); dv*=heightInMM;
    if((mitk::Equal(geometry->GetAxisVector(1), dv)==false))
    {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]";
    std::cout << ", dir=2 ";
    dv=normal; dv.Normalize(); dv*=thicknessInMM;
    if((mitk::Equal(geometry->GetAxisVector(2), dv)==false))
    {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing offset: ";
    if((mitk::Equal(geometry->GetCornerPoint(0),cornerpoint0, (double) vnl_math::float_eps)==false))
    {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]"<<std::endl;
    return EXIT_SUCCESS;
 }
 
 int testGeometry(const mitk::Geometry3D * geometry,
                  const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& numSlices,
                  const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::ScalarType& thicknessInMM,
                  const mitk::Point3D& cornerpoint0, const mitk::Vector3D& right, const mitk::Vector3D& bottom, const mitk::Vector3D& normal)
 {
    int result=EXIT_FAILURE;
 
    std::cout << "Comparing GetCornerPoint(0) of Geometry3D with provided cornerpoint0: ";
    if(mitk::Equal(geometry->GetCornerPoint(0), cornerpoint0)==false)
    {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
    }
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Creating and initializing a SliceNavigationController with the Geometry3D: ";
    mitk::SliceNavigationController::Pointer sliceCtrl = mitk::SliceNavigationController::New();
    sliceCtrl->SetInputWorldGeometry3D(geometry);
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Axial): ";
    sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing Update(): ";
    sliceCtrl->Update();
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing result of CreatedWorldGeometry(): ";
    mitk::Point3D axialcornerpoint0;
    axialcornerpoint0 = cornerpoint0+bottom+normal*(numSlices-1+0.5); //really -1?
    result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, height, numSlices, widthInMM, heightInMM, thicknessInMM*numSlices, axialcornerpoint0, right, bottom*(-1.0), normal*(-1.0));
    if(result!=EXIT_SUCCESS)
    {
       std::cout<<"[FAILED]"<<std::endl;
       return result;
    }
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Frontal): ";
    sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Frontal);
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing Update(): ";
    sliceCtrl->Update();
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing result of CreatedWorldGeometry(): ";
    mitk::Point3D frontalcornerpoint0;
    frontalcornerpoint0 = cornerpoint0+geometry->GetAxisVector(1)*(+0.5/geometry->GetExtent(1));
    result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, numSlices, height, widthInMM, thicknessInMM*numSlices, heightInMM, frontalcornerpoint0, right, normal, bottom);
    if(result!=EXIT_SUCCESS)
    {
       std::cout<<"[FAILED]"<<std::endl;
       return result;
    }
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Sagittal): ";
    sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Sagittal);
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing Update(): "<<std::endl;
    sliceCtrl->Update();
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Testing result of CreatedWorldGeometry(): ";
    mitk::Point3D sagittalcornerpoint0;
    sagittalcornerpoint0 = cornerpoint0+geometry->GetAxisVector(0)*(+0.5/geometry->GetExtent(0));
    result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), height, numSlices, width, heightInMM, thicknessInMM*numSlices, widthInMM, sagittalcornerpoint0, bottom, normal, right);
    if(result!=EXIT_SUCCESS)
    {
       std::cout<<"[FAILED]"<<std::endl;
       return result;
    }
    std::cout<<"[PASSED]"<<std::endl;
 
    return EXIT_SUCCESS;
 }
 
 int testReorientPlanes ()
 {
    //Create PlaneGeometry
    mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
 
    mitk::Point3D origin;
    mitk::Vector3D right, bottom, normal;
    mitk::ScalarType width, height;
    mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
 
    width  = 100;    widthInMM  = width;
    height = 200;    heightInMM = height;
    thicknessInMM = 1.5;
 
    mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
    mitk::FillVector3D(right,  widthInMM,          0, 0);
    mitk::FillVector3D(bottom,         0, heightInMM, 0);
    mitk::FillVector3D(normal,         0,          0, thicknessInMM);
 
    mitk::Vector3D spacing;
    normal.Normalize(); normal *= thicknessInMM;
    mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
    planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
    planegeometry->SetOrigin(origin);
 
    //Create SlicedGeometry3D out of planeGeometry
    mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New();
    unsigned int numSlices = 20;
    slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
 
    //Create another slicedgeo which will be rotated
    mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
    slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
 
    //Create  geo3D as reference
    mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
    geometry->SetBounds(slicedgeometry1->GetBounds());
    geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform());
 
    //Initialize planes
    for (int i=0; i < (int)numSlices; i++)
    {
       mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
       geo2d->Initialize();
       geo2d->SetReferenceGeometry(geometry);
-      slicedgeometry1->SetGeometry2D(geo2d,i);
+      slicedgeometry1->SetPlaneGeometry(geo2d,i);
    }
 
    for (int i=0; i < (int)numSlices; i++)
    {
       mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
       geo2d->Initialize();
       geo2d->SetReferenceGeometry(geometry);
-      slicedgeometry2->SetGeometry2D(geo2d,i);
+      slicedgeometry2->SetPlaneGeometry(geo2d,i);
    }
 
    slicedgeometry1->SetReferenceGeometry(geometry);
    slicedgeometry2->SetReferenceGeometry(geometry);
 
    //Create SNC
    mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
    sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
    sliceCtrl1->Update();
 
    mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
    sliceCtrl2->SetInputWorldGeometry3D(slicedgeometry2);
    sliceCtrl2->Update();
 
    slicedgeometry1->SetSliceNavigationController(sliceCtrl1);
    slicedgeometry2->SetSliceNavigationController(sliceCtrl2);
 
    // Whats current geometry?
    MITK_INFO << "center: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
    MITK_INFO << "normal: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal();
    MITK_INFO << "origin: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
    MITK_INFO << "axis0 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
    MITK_INFO << "aixs1 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
 
    //
    // Now reorient slices (ONE POINT, ONE NORMAL)
    mitk::Point3D oldCenter, oldOrigin;
    mitk::Vector3D oldAxis0, oldAxis1;
    oldCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
    oldOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
    oldAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
    oldAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
 
    mitk::Point3D orientCenter;
    mitk::Vector3D orientNormal;
    orientCenter = oldCenter;
    mitk::FillVector3D(orientNormal, 0.3, 0.1, 0.8);
    orientNormal.Normalize();
    sliceCtrl1->ReorientSlices(orientCenter,orientNormal);
 
    mitk::Point3D newCenter, newOrigin;
    mitk::Vector3D newNormal;
    newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
    newOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
    newNormal = sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal();
    newNormal.Normalize();
 
    itk::Index<3> orientCenterIdx;
    itk::Index<3> newCenterIdx;
    sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx);
    sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx);
 
    if (
       (newCenterIdx != orientCenterIdx)  ||
       ( !mitk::Equal(orientNormal, newNormal) )
       )
    {
       MITK_INFO << "Reorient Planes (1 point, 1 vector) not working as it should";
       MITK_INFO << "orientCenterIdx: " << orientCenterIdx;
       MITK_INFO << "newCenterIdx: " << newCenterIdx;
       MITK_INFO << "orientNormal: " << orientNormal;
       MITK_INFO << "newNormal: " << newNormal;
       return EXIT_FAILURE;
    }
 
    //
    // Now reorient slices (center, vec0, vec1 )
    mitk::Vector3D orientAxis0, orientAxis1, newAxis0, newAxis1;
    mitk::FillVector3D(orientAxis0, 1.0, 0.0, 0.0);
    mitk::FillVector3D(orientAxis1, 0.0, 1.0, 0.0);
 
    orientAxis0.Normalize();
    orientAxis1.Normalize();
 
    sliceCtrl1->ReorientSlices(orientCenter,orientAxis0, orientAxis1);
 
    newAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
    newAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
    newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
 
    newAxis0.Normalize();
    newAxis1.Normalize();
 
    sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx);
    sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx);
 
    if (
       (newCenterIdx != orientCenterIdx) ||
       ( !mitk::Equal(orientAxis0, newAxis0, 1E-12) )  ||
       ( !mitk::Equal(orientAxis1, newAxis1, 1E-12 ))
       )
    {
       MITK_INFO << "Reorient Planes (point, vec, vec) not working as it should";
       MITK_INFO << "orientCenterIdx: " << orientCenterIdx;
       MITK_INFO << "newCenterIdx: " << newCenterIdx;
       MITK_INFO << "orientAxis0: " << orientAxis0;
       MITK_INFO << "newAxis0: " << newAxis0;
       MITK_INFO << "orientAxis1: " << orientAxis1;
       MITK_INFO << "newAxis1: " << newAxis1;
       return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
 }
 
 int testRestorePlanePostionOperation ()
 {
    //Create PlaneGeometry
    mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
 
    mitk::Point3D origin;
    mitk::Vector3D right, bottom, normal;
    mitk::ScalarType width, height;
    mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
 
    width  = 100;    widthInMM  = width;
    height = 200;    heightInMM = height;
    thicknessInMM = 1.5;
 
    mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
    mitk::FillVector3D(right,  widthInMM,          0, 0);
    mitk::FillVector3D(bottom,         0, heightInMM, 0);
    mitk::FillVector3D(normal,         0,          0, thicknessInMM);
 
    mitk::Vector3D spacing;
    normal.Normalize(); normal *= thicknessInMM;
    mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
    planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
    planegeometry->SetOrigin(origin);
 
    //Create SlicedGeometry3D out of planeGeometry
    mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New();
    unsigned int numSlices = 300;
    slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
 
    //Create another slicedgeo which will be rotated
    mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
    slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
 
    //Create  geo3D as reference
    mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
    geometry->SetBounds(slicedgeometry1->GetBounds());
    geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform());
 
    //Initialize planes
    for (int i=0; i < (int)numSlices; i++)
    {
       mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
       geo2d->Initialize();
       geo2d->SetReferenceGeometry(geometry);
-      slicedgeometry1->SetGeometry2D(geo2d,i);
+      slicedgeometry1->SetPlaneGeometry(geo2d,i);
    }
 
    for (int i=0; i < (int)numSlices; i++)
    {
       mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
       geo2d->Initialize();
       geo2d->SetReferenceGeometry(geometry);
-      slicedgeometry2->SetGeometry2D(geo2d,i);
+      slicedgeometry2->SetPlaneGeometry(geo2d,i);
    }
 
    slicedgeometry1->SetReferenceGeometry(geometry);
    slicedgeometry2->SetReferenceGeometry(geometry);
 
    //Create SNC
    mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
    sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
    sliceCtrl1->Update();
 
    mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
    sliceCtrl2->SetInputWorldGeometry3D(slicedgeometry2);
    sliceCtrl2->Update();
 
    slicedgeometry1->SetSliceNavigationController(sliceCtrl1);
    slicedgeometry2->SetSliceNavigationController(sliceCtrl2);
 
    //Rotate slicedgeo2
    double angle = 63.84;
    mitk::Vector3D rotationVector; mitk::FillVector3D( rotationVector, 0.5, 0.95, 0.23 );
    mitk::Point3D center = slicedgeometry2->GetCenter();
    mitk::RotationOperation* op = new mitk::RotationOperation( mitk::OpROTATE, center, rotationVector, angle );
    slicedgeometry2->ExecuteOperation(op);
    sliceCtrl2->Update();
 
    us::ServiceReference<mitk::PlanePositionManagerService> serviceRef =
       us::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
    mitk::PlanePositionManagerService* service = us::GetModuleContext()->GetService(serviceRef);
-   service->AddNewPlanePosition(slicedgeometry2->GetGeometry2D(0), 178);
+   service->AddNewPlanePosition(slicedgeometry2->GetPlaneGeometry(0), 178);
    sliceCtrl1->ExecuteOperation(service->GetPlanePosition(0));
    sliceCtrl1->Update();
-   mitk::PlaneGeometry* planeRotated = slicedgeometry2->GetGeometry2D(178);
-   mitk::PlaneGeometry* planeRestored = dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetGeometry2D(178);
+   mitk::PlaneGeometry* planeRotated = slicedgeometry2->GetPlaneGeometry(178);
+   mitk::PlaneGeometry* planeRestored = dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetPlaneGeometry(178);
 
    try{
       MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(planeRotated->GetIndexToWorldTransform()->GetMatrix(), planeRestored->GetIndexToWorldTransform()->GetMatrix()),"Testing for IndexToWorld");
       MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetOrigin(), planeRestored->GetOrigin(),2*mitk::eps),"Testing for origin");
       MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetSpacing(), planeRestored->GetSpacing()),"Testing for spacing");
       MITK_TEST_CONDITION_REQUIRED(mitk::Equal(slicedgeometry2->GetDirectionVector(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetDirectionVector()),"Testing for directionvector");
       MITK_TEST_CONDITION_REQUIRED(mitk::Equal(slicedgeometry2->GetSlices(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetSlices()),"Testing for numslices");
       MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(slicedgeometry2->GetIndexToWorldTransform()->GetMatrix(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetIndexToWorldTransform()->GetMatrix()),"Testing for IndexToWorld");
    }
    catch(...)
    {
       return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
 }
 
 int mitkSliceNavigationControllerTest(int /*argc*/, char* /*argv*/[])
 {
    int result=EXIT_FAILURE;
 
    std::cout << "Creating and initializing a PlaneGeometry: ";
    mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
 
    mitk::Point3D origin;
    mitk::Vector3D right, bottom, normal;
    mitk::ScalarType width, height;
    mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
 
    width  = 100;    widthInMM  = width;
    height = 200;    heightInMM = height;
    thicknessInMM = 1.5;
    //  mitk::FillVector3D(origin,         0,          0, thicknessInMM*0.5);
    mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
    mitk::FillVector3D(right,  widthInMM,          0, 0);
    mitk::FillVector3D(bottom,         0, heightInMM, 0);
    mitk::FillVector3D(normal,         0,          0, thicknessInMM);
 
    mitk::Vector3D spacing;
    normal.Normalize(); normal *= thicknessInMM;
    mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
    planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
    planegeometry->SetOrigin(origin);
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Creating and initializing a SlicedGeometry3D with the PlaneGeometry: ";
    mitk::SlicedGeometry3D::Pointer slicedgeometry = mitk::SlicedGeometry3D::New();
    unsigned int numSlices = 5;
    slicedgeometry->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
    std::cout<<"[PASSED]"<<std::endl;
 
    std::cout << "Creating a Geometry3D with the same extent as the SlicedGeometry3D: ";
    mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
    geometry->SetBounds(slicedgeometry->GetBounds());
    geometry->SetIndexToWorldTransform(slicedgeometry->GetIndexToWorldTransform());
    std::cout<<"[PASSED]"<<std::endl;
 
    mitk::Point3D cornerpoint0;
    cornerpoint0 = geometry->GetCornerPoint(0);
 
    result=testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
    if(result!=EXIT_SUCCESS)
       return result;
 
    mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
    transform->SetMatrix(geometry->GetIndexToWorldTransform()->GetMatrix());
    mitk::BoundingBox::Pointer boundingbox = geometry->CalculateBoundingBoxRelativeToTransform(transform);
    geometry->SetBounds(boundingbox->GetBounds());
    cornerpoint0 = geometry->GetCornerPoint(0);
 
    result=testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
    if(result!=EXIT_SUCCESS)
       return result;
 
    std::cout << "Changing the IndexToWorldTransform of the geometry to a rotated version by SetIndexToWorldTransform() (keep cornerpoint0): ";
    transform = mitk::AffineTransform3D::New();
    mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
    vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
    mitk::VnlVector axis(3);
    mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize();
    vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
    vnlmatrix = rotation.rotation_matrix_transpose()*vnlmatrix;
    mitk::Matrix3D matrix;
    matrix = vnlmatrix;
    transform->SetMatrix(matrix);
    transform->SetOffset(cornerpoint0.GetVectorFromOrigin());
 
    right.SetVnlVector( rotation.rotation_matrix_transpose()*right.GetVnlVector() );
    bottom.SetVnlVector(rotation.rotation_matrix_transpose()*bottom.GetVnlVector());
    normal.SetVnlVector(rotation.rotation_matrix_transpose()*normal.GetVnlVector());
    geometry->SetIndexToWorldTransform(transform);
    std::cout<<"[PASSED]"<<std::endl;
 
    cornerpoint0 = geometry->GetCornerPoint(0);
 
    result = testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
    if(result!=EXIT_SUCCESS)
       return result;
 
    //Testing Execute RestorePlanePositionOperation
    result = testRestorePlanePostionOperation();
    if(result!=EXIT_SUCCESS)
       return result;
 
    // Re-Orient planes not working as it should on windows
    // However, this might be adjusted during a geometry redesign.
    /*
    //Testing  ReorientPlanes
    result = testReorientPlanes();
    if(result!=EXIT_SUCCESS)
    return result;
    */
 
    std::cout<<"[TEST DONE]"<<std::endl;
    return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp b/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
index cf36563b6c..6555c4425e 100644
--- a/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
+++ b/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
@@ -1,257 +1,257 @@
 /*===================================================================
 
 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 "mitkImage.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkTestingMacros.h"
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.txx>
 
 #include <fstream>
 
 static const mitk::ScalarType slicedGeometryEps = 1E-9; // epsilon for this testfile. Set to float precision.
 
 void mitkSlicedGeometry3D_ChangeImageGeometryConsideringOriginOffset_Test()
 {
   //Tests for Offset
   MITK_TEST_OUTPUT( << "====== NOW RUNNING: Tests for pixel-center-based offset concerns ========");
 
 
   // create a SlicedGeometry3D
   mitk::SlicedGeometry3D::Pointer slicedGeo3D=mitk::SlicedGeometry3D::New();
   int num_slices = 5;
   slicedGeo3D->InitializeSlicedGeometry(num_slices); // 5 slices
   mitk::Point3D newOrigin;
   newOrigin[0] = 91.3;
   newOrigin[1] = -13.3;
   newOrigin[2] = 0;
   slicedGeo3D->SetOrigin(newOrigin);
   mitk::Vector3D newSpacing;
   newSpacing[0] = 1.0f;
   newSpacing[1] = 0.9f;
   newSpacing[2] = 0.3f;
   slicedGeo3D->SetSpacing(newSpacing);
   // create subslices as well
   for (int i=0; i < num_slices; i++)
   {
     mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
     geo2d->Initialize();
-    slicedGeo3D->SetGeometry2D(geo2d,i);
+    slicedGeo3D->SetPlaneGeometry(geo2d,i);
   }
 
   // now run tests
 
   MITK_TEST_OUTPUT( << "Testing whether slicedGeo3D->GetImageGeometry() is false by default");
   MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetImageGeometry()==false, "");
   MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==false by default");
-  mitk::BaseGeometry* subSliceGeo2D_first = slicedGeo3D->GetGeometry2D(0);
-  mitk::BaseGeometry* subSliceGeo2D_last = slicedGeo3D->GetGeometry2D(num_slices-1);
+  mitk::BaseGeometry* subSliceGeo2D_first = slicedGeo3D->GetPlaneGeometry(0);
+  mitk::BaseGeometry* subSliceGeo2D_last = slicedGeo3D->GetPlaneGeometry(num_slices-1);
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetImageGeometry()==false, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetImageGeometry()==false, "");
 
   // Save some Origins and cornerpoints
   mitk::Point3D OriginSlicedGeo( slicedGeo3D->GetOrigin() );
   mitk::Point3D OriginFirstGeo( subSliceGeo2D_first->GetOrigin() );
   mitk::Point3D OriginLastGeo( subSliceGeo2D_last->GetOrigin() );
   mitk::Point3D CornerPoint0SlicedGeo(slicedGeo3D->GetCornerPoint(0));
   mitk::Point3D CornerPoint1FirstGeo(subSliceGeo2D_first->GetCornerPoint(1));
   mitk::Point3D CornerPoint2LastGeo(subSliceGeo2D_last->GetCornerPoint(2));
 
   MITK_TEST_OUTPUT( << "Calling slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(true)");
   //std::cout << "vorher Origin: " << subSliceGeo2D_first->GetOrigin() << std::endl;
   //std::cout << "vorher Corner: " << subSliceGeo2D_first->GetCornerPoint(0) << std::endl;
   slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(true);
   //std::cout << "nachher Origin: " << subSliceGeo2D_first->GetOrigin() << std::endl;
   //std::cout << "nachher Corner: " << subSliceGeo2D_first->GetCornerPoint(0) << std::endl;
   MITK_TEST_OUTPUT( << "Testing whether slicedGeo3D->GetImageGeometry() is now true");
   MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetImageGeometry()==true, "");
   MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==true now");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetImageGeometry()==true, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetImageGeometry()==true, "");
 
   MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins");
   // Manually adding Offset.
   OriginSlicedGeo[0] += (slicedGeo3D->GetSpacing()[0]) / 2;
   OriginSlicedGeo[1] += (slicedGeo3D->GetSpacing()[1]) / 2;
   OriginSlicedGeo[2] += (slicedGeo3D->GetSpacing()[2]) / 2;
   OriginFirstGeo[0] += (subSliceGeo2D_first->GetSpacing()[0]) / 2;
   OriginFirstGeo[1] += (subSliceGeo2D_first->GetSpacing()[1]) / 2;
   OriginFirstGeo[2] += (subSliceGeo2D_first->GetSpacing()[2]) / 2;
   OriginLastGeo[0] += (subSliceGeo2D_last->GetSpacing()[0]) / 2;
   OriginLastGeo[1] += (subSliceGeo2D_last->GetSpacing()[1]) / 2;
   OriginLastGeo[2] += (subSliceGeo2D_last->GetSpacing()[2]) / 2;
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
   MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetCornerPoint(0)==CornerPoint0SlicedGeo, "");
   MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetOrigin()==OriginSlicedGeo, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetOrigin()==OriginFirstGeo, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetOrigin()==OriginLastGeo, "");
 
   MITK_TEST_OUTPUT( << "Calling slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(false)");
   slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(false);
   MITK_TEST_OUTPUT( << "Testing whether slicedGeo3D->GetImageGeometry() is now false");
   MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetImageGeometry()==false, "");
   MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==false now");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetImageGeometry()==false, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetImageGeometry()==false, "");
 
   MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins of geometry");
 
   // Manually substracting Offset.
   OriginSlicedGeo[0] -= (slicedGeo3D->GetSpacing()[0]) / 2;
   OriginSlicedGeo[1] -= (slicedGeo3D->GetSpacing()[1]) / 2;
   OriginSlicedGeo[2] -= (slicedGeo3D->GetSpacing()[2]) / 2;
   OriginFirstGeo[0] -= (subSliceGeo2D_first->GetSpacing()[0]) / 2;
   OriginFirstGeo[1] -= (subSliceGeo2D_first->GetSpacing()[1]) / 2;
   OriginFirstGeo[2] -= (subSliceGeo2D_first->GetSpacing()[2]) / 2;
   OriginLastGeo[0] -= (subSliceGeo2D_last->GetSpacing()[0]) / 2;
   OriginLastGeo[1] -= (subSliceGeo2D_last->GetSpacing()[1]) / 2;
   OriginLastGeo[2] -= (subSliceGeo2D_last->GetSpacing()[2]) / 2;
 
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
   MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetCornerPoint(0)==CornerPoint0SlicedGeo, "");
   MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetOrigin()==OriginSlicedGeo, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetOrigin()==OriginFirstGeo, "");
   MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetOrigin()==OriginLastGeo, "");
 
   MITK_TEST_OUTPUT( << "ALL SUCCESSFULLY!");
 }
 
 int mitkSlicedGeometry3DTest(int /*argc*/, char* /*argv*/[])
 {
   mitk::PlaneGeometry::Pointer planegeometry1 = mitk::PlaneGeometry::New();
 
   mitk::Point3D origin;
   mitk::Vector3D right, bottom, normal;
   mitk::ScalarType width, height;
   mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
 
   width  = 100;    widthInMM  = width;
   height = 200;    heightInMM = height;
   thicknessInMM = 3.5;
   mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
   mitk::FillVector3D(right,  widthInMM,          0, 0);
   mitk::FillVector3D(bottom,         0, heightInMM, 0);
   mitk::FillVector3D(normal,         0,          0, thicknessInMM);
 
   std::cout << "Initializing planegeometry1 by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
   planegeometry1->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector());
 
   std::cout << "Setting planegeometry2 to a cloned version of planegeometry1: "<<std::endl;
   mitk::PlaneGeometry::Pointer planegeometry2;
   planegeometry2 = dynamic_cast<mitk::PlaneGeometry*>(planegeometry1->Clone().GetPointer());;
 
   std::cout << "Changing the IndexToWorldTransform of planegeometry2 to a rotated version by SetIndexToWorldTransform() (keep origin): "<<std::endl;
   mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
   mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
   vnlmatrix = planegeometry2->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
   mitk::VnlVector axis(3);
   mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize();
   vnl_quaternion<mitk::ScalarType> rotation(axis, 0.123);
   vnlmatrix = rotation.rotation_matrix_transpose()*vnlmatrix;
   mitk::Matrix3D matrix;
   matrix = vnlmatrix;
   transform->SetMatrix(matrix);
   transform->SetOffset(planegeometry2->GetIndexToWorldTransform()->GetOffset());
 
   right.SetVnlVector( rotation.rotation_matrix_transpose()*right.GetVnlVector() );
   bottom.SetVnlVector(rotation.rotation_matrix_transpose()*bottom.GetVnlVector());
   normal.SetVnlVector(rotation.rotation_matrix_transpose()*normal.GetVnlVector());
   planegeometry2->SetIndexToWorldTransform(transform);
 
 
   std::cout << "Setting planegeometry3 to the backside of planegeometry2: " <<std::endl;
   mitk::PlaneGeometry::Pointer planegeometry3 = mitk::PlaneGeometry::New();
   planegeometry3->InitializeStandardPlane(planegeometry2, mitk::PlaneGeometry::Axial, 0, false);
 
 
   std::cout << "Testing SlicedGeometry3D::InitializeEvenlySpaced(planegeometry3, zSpacing = 1, slices = 5, flipped = false): " <<std::endl;
   mitk::SlicedGeometry3D::Pointer slicedWorldGeometry=mitk::SlicedGeometry3D::New();
   unsigned int numSlices = 5;
   slicedWorldGeometry->InitializeEvenlySpaced(planegeometry3, 1, numSlices, false);
 
   std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the SlicedGeometry3D: ";
-  mitk::PlaneGeometry* accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(0));
+  mitk::PlaneGeometry* accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetPlaneGeometry(0));
   if(accessedplanegeometry3==NULL)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing whether the first geometry in the SlicedGeometry3D is identical to planegeometry3 by axis comparison and origin: "<<std::endl;
   if((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin(), slicedGeometryEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing availability and type (PlaneGeometry) of the last geometry in the SlicedGeometry3D: ";
-  mitk::PlaneGeometry* accessedplanegeometry3last = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(numSlices-1));
+  mitk::PlaneGeometry* accessedplanegeometry3last = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetPlaneGeometry(numSlices-1));
   mitk::Point3D origin3last; origin3last = planegeometry3->GetOrigin()+slicedWorldGeometry->GetDirectionVector()*(numSlices-1);
   if(accessedplanegeometry3last==NULL)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing whether the last geometry in the SlicedGeometry3D is identical to planegeometry3 by axis comparison: "<<std::endl;
   if((mitk::Equal(accessedplanegeometry3last->GetAxisVector(0), planegeometry3->GetAxisVector(0), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetAxisVector(1), planegeometry3->GetAxisVector(1), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetAxisVector(2), planegeometry3->GetAxisVector(2), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetOrigin(), origin3last, slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetIndexToWorldTransform()->GetOffset(), origin3last.GetVectorFromOrigin(), slicedGeometryEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Again for first slice - Testing availability and type (PlaneGeometry) of first geometry in the SlicedGeometry3D: ";
-  accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(0));
+  accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetPlaneGeometry(0));
   if(accessedplanegeometry3==NULL)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Again for first slice - Testing whether the first geometry in the SlicedGeometry3D is identical to planegeometry3 by axis comparison and origin: "<<std::endl;
   if((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin(), slicedGeometryEps)==false) ||
      (mitk::Equal(accessedplanegeometry3->GetIndexToWorldTransform()->GetOffset(), planegeometry3->GetOrigin().GetVectorFromOrigin(), slicedGeometryEps)==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   mitkSlicedGeometry3D_ChangeImageGeometryConsideringOriginOffset_Test();
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index 8c53bd7ac0..dcae46c7cb 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,404 +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/mitkTimeSlicedGeometry.h # Deprecated, empty for compatibility 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/mitkPlaneGeometryDataToSurfaceFilter.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/mitkBaseGeometry.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/mitkGeometry2DData.cpp
+  DataManagement/mitkPlaneGeometryData.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/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/mitkPlaneGeometryDataMapper2D.cpp
+  Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkGLMapper.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.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/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/AlgorithmsExt/mitkAutoCropImageFilter.cpp b/Modules/AlgorithmsExt/mitkAutoCropImageFilter.cpp
index 4f9a7ca59a..a40080264a 100644
--- a/Modules/AlgorithmsExt/mitkAutoCropImageFilter.cpp
+++ b/Modules/AlgorithmsExt/mitkAutoCropImageFilter.cpp
@@ -1,363 +1,363 @@
 /*===================================================================
 
 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 "mitkAutoCropImageFilter.h"
 
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkGeometry3D.h"
 #include "mitkStatusBar.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkPlaneGeometry.h"
 
 #include <itkImageRegionConstIterator.h>
 #include <itkRegionOfInterestImageFilter.h>
 #include <mitkProportionalTimeGeometry.h>
 
 
 mitk::AutoCropImageFilter::AutoCropImageFilter()
 : m_BackgroundValue(0),
   m_MarginFactor(1.0),
   m_TimeSelector(NULL),
   m_OverrideCroppingRegion(false)
 {
 }
 
 
 mitk::AutoCropImageFilter::~AutoCropImageFilter()
 {
 }
 
 
 template < typename TPixel, unsigned int VImageDimension>
 void mitk::AutoCropImageFilter::ITKCrop3DImage( itk::Image< TPixel, VImageDimension >* inputItkImage, unsigned int timestep)
 {
   if (inputItkImage == NULL)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText ("An internal error occurred. Can't convert Image. Please report to bugs@mitk.org");
     MITK_ERROR << "image is NULL...returning" << std::endl;
     return;
   }
 
   typedef itk::Image< TPixel, VImageDimension > InternalImageType;
   typedef typename InternalImageType::Pointer   InternalImagePointer;
 
   typedef itk::RegionOfInterestImageFilter < InternalImageType, InternalImageType > ROIFilterType;
   typedef typename itk::RegionOfInterestImageFilter < InternalImageType, InternalImageType >::Pointer ROIFilterPointer;
 
   InternalImagePointer outputItk = InternalImageType::New();
 
   ROIFilterPointer roiFilter = ROIFilterType::New();
   roiFilter->SetInput(0,inputItkImage);
   roiFilter->SetRegionOfInterest(this->GetCroppingRegion());
   roiFilter->Update();
   outputItk = roiFilter->GetOutput();
   outputItk->DisconnectPipeline();
 
   mitk::Image::Pointer newMitkImage = mitk::Image::New();
   mitk::CastToMitkImage( outputItk, newMitkImage );
   MITK_INFO << "Crop-Output dimension: " << (newMitkImage->GetDimension() == 3) << " Filter-Output dimension: "<<this->GetOutput()->GetDimension()<< " Timestep: " << timestep;
 
   mitk::ImageReadAccessor newMitkImgAcc(newMitkImage);
   this->GetOutput()->SetVolume( newMitkImgAcc.GetData(), timestep);
 }
 
 void mitk::AutoCropImageFilter::GenerateOutputInformation()
 {
   mitk::Image::Pointer input = const_cast<mitk::Image*> (this->GetInput());
   mitk::Image::Pointer output = this->GetOutput();
 
   if(input->GetDimension() <= 2)
   {
     MITK_ERROR << "Only 3D any 4D images are supported." << std::endl;
     return;
   }
 
   ComputeNewImageBounds();
 
   if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   // PART I: initialize input requested region. We do this already here (and not
   // later when GenerateInputRequestedRegion() is called), because we
   // also need the information to setup the output.
 
   // pre-initialize input-requested-region to largest-possible-region
   // and correct time-region; spatial part will be cropped by
   // bounding-box of bounding-object below
   m_InputRequestedRegion = input->GetLargestPossibleRegion();
 
   // build region out of index and size calculated in ComputeNewImageBounds()
 
   mitk::SlicedData::IndexType index;
   index[0] = m_RegionIndex[0];
   index[1] = m_RegionIndex[1];
   index[2] = m_RegionIndex[2];
   index[3] = m_InputRequestedRegion.GetIndex()[3];
   index[4] = m_InputRequestedRegion.GetIndex()[4];
 
   mitk::SlicedData::SizeType  size;
   size[0] = m_RegionSize[0];
   size[1] = m_RegionSize[1];
   size[2] = m_RegionSize[2];
   size[3] = m_InputRequestedRegion.GetSize()[3];
   size[4] = m_InputRequestedRegion.GetSize()[4];
 
   mitk::SlicedData::RegionType cropRegion(index, size);
 
   // crop input-requested-region with cropping region computed from the image data
   if(m_InputRequestedRegion.Crop(cropRegion)==false)
   {
     // crop not possible => do nothing: set time size to 0.
     size.Fill(0);
     m_InputRequestedRegion.SetSize(size);
     return;
   }
 
   // set input-requested-region, because we access it later in
   // GenerateInputRequestedRegion (there we just set the time)
   input->SetRequestedRegion(&m_InputRequestedRegion);
 
 
   // PART II: initialize output image
   unsigned int dimension = input->GetDimension();
   unsigned int *dimensions = new unsigned int [dimension];
   itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
   if(dimension>3)
     memcpy(dimensions+3, input->GetDimensions()+3, (dimension-3)*sizeof(unsigned int));
 
   // create basic slicedGeometry that will be initialized below
   output->Initialize(mitk::PixelType( GetOutputPixelType() ), dimension, dimensions);
   delete [] dimensions;
 
   //clone the IndexToWorldTransform from the input, otherwise we will overwrite it, when adjusting the origin of the output image!!
   itk::ScalableAffineTransform< mitk::ScalarType,3 >::Pointer cloneTransform = itk::ScalableAffineTransform< mitk::ScalarType,3 >::New();
   cloneTransform->Compose(input->GetGeometry()->GetIndexToWorldTransform());
   output->GetGeometry()->SetIndexToWorldTransform( cloneTransform.GetPointer() );
 
   // Position the output Image to match the corresponding region of the input image
   mitk::SlicedGeometry3D* slicedGeometry = output->GetSlicedGeometry();
   mitk::SlicedGeometry3D::Pointer inputGeometry = input->GetSlicedGeometry();
   const mitk::SlicedData::IndexType& start = m_InputRequestedRegion.GetIndex();
   mitk::Point3D origin; vtk2itk(start, origin);
   input->GetSlicedGeometry()->IndexToWorld(origin, origin);
   slicedGeometry->SetOrigin(origin);
 
   // get the PlaneGeometry for the first slice of the original image
-  mitk::PlaneGeometry::Pointer plane = dynamic_cast<mitk::PlaneGeometry*>( inputGeometry->GetGeometry2D( 0 )->Clone().GetPointer() );
+  mitk::PlaneGeometry::Pointer plane = dynamic_cast<mitk::PlaneGeometry*>( inputGeometry->GetPlaneGeometry( 0 )->Clone().GetPointer() );
   assert( plane );
 
   // re-initialize the plane according to the new requirements:
   // dimensions of the cropped image
   // right- and down-vector as well as spacing do not change, so use the ones from
   // input image
   ScalarType dimX = output->GetDimensions()[0];
   ScalarType dimY = output->GetDimensions()[1];
   mitk::Vector3D right = plane->GetAxisVector(0);
   mitk::Vector3D down = plane->GetAxisVector(1);
   mitk::Vector3D spacing = plane->GetSpacing();
   plane->InitializeStandardPlane( dimX, dimY, right, down, &spacing );
   // set the new origin on the PlaneGeometry as well
   plane->SetOrigin(origin);
 
   // re-initialize the slicedGeometry with the correct planeGeometry
   // in order to get a fully initialized SlicedGeometry3D
   slicedGeometry->InitializeEvenlySpaced( plane, inputGeometry->GetSpacing()[2], output->GetSlicedGeometry()->GetSlices() );
 
 
   mitk::TimeGeometry* timeSlicedGeometry = output->GetTimeGeometry();
   mitk::ProportionalTimeGeometry* propTimeGeometry = dynamic_cast<ProportionalTimeGeometry*>(timeSlicedGeometry);
   propTimeGeometry->Initialize(slicedGeometry, output->GetDimension(3));
 
   m_TimeOfHeaderInitialization.Modified();
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 }
 
 void mitk::AutoCropImageFilter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if(input.IsNull())
     return;
 
   if(input->GetDimension() <= 2)
   {
     MITK_ERROR << "Only 3D and 4D images supported";
     return;
   }
 
   if((output->IsInitialized()==false) )
     return;
 
   if( m_TimeSelector.IsNull() ) m_TimeSelector = mitk::ImageTimeSelector::New();
 
   m_TimeSelector->SetInput(input);
 
   mitk::SlicedData::RegionType outputRegion = input->GetRequestedRegion();
 
   int tstart = outputRegion.GetIndex(3);
   int tmax = tstart + outputRegion.GetSize(3);
 
   for( int timestep=tstart;timestep<tmax;++timestep )
   {
     m_TimeSelector->SetTimeNr(timestep);
     m_TimeSelector->UpdateLargestPossibleRegion();
 
     AccessFixedDimensionByItk_1( m_TimeSelector->GetOutput(), ITKCrop3DImage, 3, timestep );
   }
 
   // this->GetOutput()->Update(); // Not sure if this is necessary...
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void mitk::AutoCropImageFilter::ComputeNewImageBounds()
 {
   mitk::Image::ConstPointer inputMitk = this->GetInput();
 
   if (m_OverrideCroppingRegion)
   {
     for (unsigned int i=0; i<3; ++i)
     {
       m_RegionIndex[i] = m_CroppingRegion.GetIndex()[i];
       m_RegionSize[i] = m_CroppingRegion.GetSize()[i];
 
       if (m_RegionIndex[i] >= static_cast<RegionType::IndexValueType>(inputMitk->GetDimension(i)))
       {
         itkExceptionMacro("Cropping index is not inside the image. "
                        << std::endl << "Index:"
                        << std::endl << m_CroppingRegion.GetIndex()
                        << std::endl << "Size:"
                        << std::endl << m_CroppingRegion.GetSize());
       }
 
       if (m_RegionIndex[i] + m_RegionSize[i] >= inputMitk->GetDimension(i))
       {
         m_RegionSize[i] = inputMitk->GetDimension(i) - m_RegionIndex[i];
       }
     }
 
     for (unsigned int i=0; i<3; ++i)
     {
       m_RegionIndex[i] = m_CroppingRegion.GetIndex()[i];
       m_RegionSize[i] = m_CroppingRegion.GetSize()[i];
     }
   }
   else
   {
     // Check if a 3D or 4D image is present
     unsigned int timeSteps = 1;
     if (inputMitk->GetDimension() == 4 )
       timeSteps = inputMitk->GetDimension(3);
 
     ImageType::IndexType minima,maxima;
 
     if (inputMitk->GetDimension() == 4)
     {
       // initialize with time step 0
       m_TimeSelector = mitk::ImageTimeSelector::New();
       m_TimeSelector->SetInput( inputMitk );
       m_TimeSelector->SetTimeNr( 0 );
       m_TimeSelector->UpdateLargestPossibleRegion();
       inputMitk = m_TimeSelector->GetOutput();
     }
 
     ImagePointer inputItk = ImageType::New();
     mitk::CastToItkImage( inputMitk , inputItk );
 
     // it is assumed that all volumes in a time series have the same 3D dimensions
     ImageType::RegionType origRegion = inputItk->GetLargestPossibleRegion();
 
     // Initialize min and max on the first (or only) time step
     maxima = inputItk->GetLargestPossibleRegion().GetIndex();
     minima[0] = inputItk->GetLargestPossibleRegion().GetSize()[0];
     minima[1] = inputItk->GetLargestPossibleRegion().GetSize()[1];
     minima[2] = inputItk->GetLargestPossibleRegion().GetSize()[2];
 
     typedef itk::ImageRegionConstIterator< ImageType > ConstIteratorType;
 
     for(unsigned int idx = 0; idx < timeSteps; ++idx)
     {
        // if 4D image, update time step and itk image
       if( idx > 0)
       {
         m_TimeSelector->SetTimeNr( idx );
         m_TimeSelector->UpdateLargestPossibleRegion();
         inputMitk = m_TimeSelector->GetOutput();
         mitk::CastToItkImage( inputMitk , inputItk );
       }
 
       ConstIteratorType inIt( inputItk,  origRegion );
 
       for ( inIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt)
       {
         float pix_val = inIt.Get();
         if ( fabs(pix_val - m_BackgroundValue) > mitk::eps )
         {
           for (int i=0; i < 3; i++)
           {
             minima[i] = vnl_math_min((int)minima[i],(int)(inIt.GetIndex()[i]));
             maxima[i] = vnl_math_max((int)maxima[i],(int)(inIt.GetIndex()[i]));
           }
         }
       }
     }
 
     typedef ImageType::RegionType::SizeType::SizeValueType  SizeValueType;
 
     m_RegionSize[0] = (SizeValueType)(m_MarginFactor * (maxima[0] - minima[0] + 1 ));
     m_RegionSize[1] = (SizeValueType)(m_MarginFactor * (maxima[1] - minima[1] + 1 ));
     m_RegionSize[2] = (SizeValueType)(m_MarginFactor * (maxima[2] - minima[2] + 1 ));
     m_RegionIndex = minima;
 
     m_RegionIndex[0] -= (m_RegionSize[0] - maxima[0] + minima[0] - 1 )/2;
     m_RegionIndex[1] -= (m_RegionSize[1] - maxima[1] + minima[1] - 1 )/2;
     m_RegionIndex[2] -= (m_RegionSize[2] - maxima[2] + minima[2] - 1 )/2;
 
     ImageType::RegionType cropRegion(m_RegionIndex,m_RegionSize);
     origRegion.Crop(cropRegion);
 
     m_RegionSize[0] = origRegion.GetSize()[0];
     m_RegionSize[1] = origRegion.GetSize()[1];
     m_RegionSize[2] = origRegion.GetSize()[2];
 
     m_RegionIndex[0] = origRegion.GetIndex()[0];
     m_RegionIndex[1] = origRegion.GetIndex()[1];
     m_RegionIndex[2] = origRegion.GetIndex()[2];
 
     m_CroppingRegion = origRegion;
   }
 }
 
 
 void mitk::AutoCropImageFilter::GenerateInputRequestedRegion()
 {
 }
 
 const mitk::PixelType mitk::AutoCropImageFilter::GetOutputPixelType()
 {
   return this->GetInput()->GetPixelType();
 }
 
 void mitk::AutoCropImageFilter::SetCroppingRegion(RegionType overrideRegion)
 {
   m_CroppingRegion = overrideRegion;
   m_OverrideCroppingRegion = true;
 }
diff --git a/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.cpp b/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.cpp
index f105518a38..7fcaadd8bc 100644
--- a/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.cpp
+++ b/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.cpp
@@ -1,263 +1,263 @@
 /*===================================================================
 
 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 "mitkGeometryClipImageFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkTimeHelper.h"
 #include "mitkProperties.h"
 
 #include "mitkImageToItk.h"
 
 #include "itkImageRegionConstIterator.h"
 #include "itkImageRegionIteratorWithIndex.h"
 
 #include <limits>
 
 mitk::GeometryClipImageFilter::GeometryClipImageFilter()
   : m_ClippingGeometry(NULL),
     m_ClipPartAboveGeometry(true),
     m_OutsideValue(0),
     m_AutoOutsideValue(false),
     m_LabelBothSides(false),
     m_AutoOrientLabels(false),
     m_AboveGeometryLabel(1),
     m_BelowGeometryLabel(2)
 {
   this->SetNumberOfIndexedInputs(2);
   this->SetNumberOfRequiredInputs(2);
   m_InputTimeSelector  = mitk::ImageTimeSelector::New();
   m_OutputTimeSelector = mitk::ImageTimeSelector::New();
   m_ClippingGeometryData = mitk::GeometryData::New();
 }
 
 mitk::GeometryClipImageFilter::~GeometryClipImageFilter()
 {
 
 }
 
 
 void mitk::GeometryClipImageFilter::SetClippingGeometry(const mitk::TimeGeometry* timeClippingGeometry)
 {
   m_TimeClippingGeometry = timeClippingGeometry;
   SetClippingGeometry(timeClippingGeometry->GetGeometryForTimeStep(0));
 }
 
 void mitk::GeometryClipImageFilter::SetClippingGeometry(const mitk::BaseGeometry* aClippingGeometry)
 {
   if(aClippingGeometry != m_ClippingGeometry.GetPointer())
   {
     m_ClippingGeometry = aClippingGeometry;
     m_ClippingGeometryData->SetGeometry(const_cast<mitk::BaseGeometry*>(aClippingGeometry));
     SetNthInput(1, m_ClippingGeometryData);
     Modified();
   }
 }
 
 const mitk::BaseGeometry* mitk::GeometryClipImageFilter::GetClippingGeometry() const
 {
   return m_ClippingGeometry;
 }
 
 const mitk::TimeGeometry* mitk::GeometryClipImageFilter::GetClippingTimeGeometry() const
 {
   return m_TimeClippingGeometry;
 }
 
 void mitk::GeometryClipImageFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::Image* output = this->GetOutput();
   mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
   if((output->IsInitialized()==false) || (m_ClippingGeometry.IsNull()))
     return;
 
   input->SetRequestedRegionToLargestPossibleRegion();
 
   GenerateTimeInInputRegion(output, input);
 }
 
 void mitk::GeometryClipImageFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   unsigned int i;
   unsigned int *tmpDimensions = new unsigned int[input->GetDimension()];
 
   for(i=0;i<input->GetDimension();++i)
     tmpDimensions[i]=input->GetDimension(i);
 
   output->Initialize(input->GetPixelType(),
     input->GetDimension(),
     tmpDimensions,
     input->GetNumberOfChannels());
 
   delete [] tmpDimensions;
 
   output->SetGeometry(static_cast<mitk::BaseGeometry*>(input->GetGeometry()->Clone().GetPointer()));
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 template < typename TPixel, unsigned int VImageDimension >
-void mitk::_InternalComputeClippedImage(itk::Image<TPixel, VImageDimension>* inputItkImage, mitk::GeometryClipImageFilter* geometryClipper, const mitk::PlaneGeometry* clippingGeometry2D)
+void mitk::_InternalComputeClippedImage(itk::Image<TPixel, VImageDimension>* inputItkImage, mitk::GeometryClipImageFilter* geometryClipper, const mitk::PlaneGeometry* clippingPlaneGeometry)
 {
   typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
   typedef itk::Image<TPixel, VImageDimension> ItkOutputImageType;
 
   typedef itk::ImageRegionConstIteratorWithIndex< ItkInputImageType > ItkInputImageIteratorType;
   typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
 
   typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
   outputimagetoitk->SetInput(geometryClipper->m_OutputTimeSelector->GetOutput());
   outputimagetoitk->Update();
   typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
 
   // create the iterators
   typename ItkInputImageType::RegionType inputRegionOfInterest = inputItkImage->GetLargestPossibleRegion();
   ItkInputImageIteratorType  inputIt( inputItkImage, inputRegionOfInterest );
   ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
 
   typename ItkOutputImageType::PixelType outsideValue;
   if(geometryClipper->m_AutoOutsideValue)
     outsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
   else
     outsideValue = (typename ItkOutputImageType::PixelType) geometryClipper->m_OutsideValue;
 
   mitk::BaseGeometry* inputGeometry = geometryClipper->m_InputTimeSelector->GetOutput()->GetGeometry();
   typedef itk::Index<VImageDimension> IndexType;
   Point3D indexPt; indexPt.Fill(0);
   int i, dim=IndexType::GetIndexDimension();
   Point3D pointInMM;
   bool above = geometryClipper->m_ClipPartAboveGeometry;
   bool labelBothSides = geometryClipper->GetLabelBothSides();
 
   if (geometryClipper->GetAutoOrientLabels())
   {
     Point3D leftMostPoint;
     leftMostPoint.Fill( std::numeric_limits<float>::min() / 2.0 );
-    if(clippingGeometry2D->IsAbove(pointInMM) != above)
+    if(clippingPlaneGeometry->IsAbove(pointInMM) != above)
       {
       // invert meaning of above --> left is always the "above" side
       above = !above;
     MITK_INFO << leftMostPoint << " is BELOW geometry. Inverting meaning of above" << std::endl;
     }
     else
     MITK_INFO << leftMostPoint << " is above geometry" << std::endl;
   }
 
   typename ItkOutputImageType::PixelType aboveLabel = (typename ItkOutputImageType::PixelType)geometryClipper->GetAboveGeometryLabel();
   typename ItkOutputImageType::PixelType belowLabel = (typename ItkOutputImageType::PixelType)geometryClipper->GetBelowGeometryLabel();
 
   for ( inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt)
   {
     if((typename ItkOutputImageType::PixelType)inputIt.Get() == outsideValue)
     {
       outputIt.Set(outsideValue);
     }
     else
     {
       for(i=0;i<dim;++i)
         indexPt[i]=(mitk::ScalarType)inputIt.GetIndex()[i];
       inputGeometry->IndexToWorld(indexPt, pointInMM);
-      if(clippingGeometry2D->IsAbove(pointInMM) == above)
+      if(clippingPlaneGeometry->IsAbove(pointInMM) == above)
       {
         if ( labelBothSides )
           outputIt.Set( aboveLabel );
         else
           outputIt.Set( outsideValue );
       }
       else
       {
         if ( labelBothSides)
           outputIt.Set( belowLabel );
         else
           outputIt.Set( inputIt.Get() );
       }
     }
   }
 }
 
 #include "mitkImageAccessByItk.h"
 
 void mitk::GeometryClipImageFilter::GenerateData()
 {
   Image::ConstPointer input = this->GetInput();
   Image::Pointer output = this->GetOutput();
 
   if((output->IsInitialized()==false) || (m_ClippingGeometry.IsNull()))
     return;
 
   const PlaneGeometry * clippingGeometryOfCurrentTimeStep = NULL;
 
   if(m_TimeClippingGeometry.IsNull())
   {
     clippingGeometryOfCurrentTimeStep = dynamic_cast<const PlaneGeometry*>(m_ClippingGeometry.GetPointer());
   }
   else
   {
     clippingGeometryOfCurrentTimeStep = dynamic_cast<const PlaneGeometry*>(m_TimeClippingGeometry->GetGeometryForTimeStep(0).GetPointer());
   }
 
   if(clippingGeometryOfCurrentTimeStep == NULL)
     return;
 
   m_InputTimeSelector->SetInput(input);
   m_OutputTimeSelector->SetInput(this->GetOutput());
 
   mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
   const mitk::TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
   const mitk::TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
   ScalarType timeInMS;
 
   int timestep=0;
   int tstart=outputRegion.GetIndex(3);
   int tmax=tstart+outputRegion.GetSize(3);
 
   int t;
   for(t=tstart;t<tmax;++t)
   {
     timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
     timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
 
     m_InputTimeSelector->SetTimeNr(timestep);
     m_InputTimeSelector->UpdateLargestPossibleRegion();
     m_OutputTimeSelector->SetTimeNr(t);
     m_OutputTimeSelector->UpdateLargestPossibleRegion();
 
     if(m_TimeClippingGeometry.IsNotNull())
     {
       timestep = m_TimeClippingGeometry->TimePointToTimeStep( timeInMS );
       if(m_TimeClippingGeometry->IsValidTimeStep(timestep) == false)
         continue;
 
       clippingGeometryOfCurrentTimeStep = dynamic_cast<const PlaneGeometry*>(m_TimeClippingGeometry->GetGeometryForTimeStep(timestep).GetPointer());
     }
 
     AccessByItk_2(m_InputTimeSelector->GetOutput(),_InternalComputeClippedImage,this,clippingGeometryOfCurrentTimeStep);
   }
 
   m_TimeOfHeaderInitialization.Modified();
 }
diff --git a/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.h b/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.h
index 4c65f5fa54..ee573543eb 100644
--- a/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.h
+++ b/Modules/AlgorithmsExt/mitkGeometryClipImageFilter.h
@@ -1,181 +1,181 @@
 /*===================================================================
 
 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 MITKGEOMETRYCLIPIMAGEFILTER_H_HEADER_INCLUDED_C1F48A22
 #define MITKGEOMETRYCLIPIMAGEFILTER_H_HEADER_INCLUDED_C1F48A22
 
 #include "mitkCommon.h"
 #include "MitkAlgorithmsExtExports.h"
 #include "mitkImageToImageFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkGeometryData.h"
 
 namespace itk {
 template <class TPixel, unsigned int VImageDimension> class ITK_EXPORT Image;
 }
 
 namespace mitk {
 
 //##Documentation
 //## @brief Filter for clipping an image with a PlaneGeometry
 //##
 //## The given geometry for clipping can be either a PlaneGeometry
 //## or a TimeGeometry containing multiple instances
 //## of PlaneGeometry
 //##
 //## \todo add AutoOrientLabels, which makes the "left" side (minimum X value) side of the image get one defined label.
 //##       left-most because vtkPolyDataNormals uses the same definition and this filter is used for visualization of
 //##       front/back side of curved planes
 //##
 //## @ingroup Process
 class MitkAlgorithmsExt_EXPORT GeometryClipImageFilter : public ImageToImageFilter
 {
 public:
   mitkClassMacro(GeometryClipImageFilter, ImageToImageFilter);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /**
   * Set the geometry to be used for clipping
   *
   * The given geometry for clipping must be a PlaneGeometry.
   */
   void SetClippingGeometry(const mitk::BaseGeometry* aClippingGeometry);
 
   /**
   * Set the geometry to be used for clipping
   *
   * The given geometry for clipping must a
   * TimeGeometry containing multiple instances
   * of PlaneGeometry
   */
   void SetClippingGeometry(const mitk::TimeGeometry* aClippingGeometry);
 
   const mitk::BaseGeometry* GetClippingGeometry() const;
   const mitk::TimeGeometry* GetClippingTimeGeometry() const;
 
   //##Description
   //## @brief Get whether the part above or below the geometry
   //## shall be clipped (default: @a true)
   itkGetConstMacro(ClipPartAboveGeometry, bool);
   //## @brief Set whether the part above or below the geometry
   //## shall be clipped (default: @a true)
   itkSetMacro(ClipPartAboveGeometry, bool);
   //## @brief Set whether the part above or below the geometry
   //## shall be clipped (default: @a true)
   itkBooleanMacro(ClipPartAboveGeometry);
 
   //##Description
   //## @brief Set value for outside pixels (default: 0),
   //## used when m_AutoOutsideValue is \a false
   itkSetMacro(OutsideValue, ScalarType);
   itkGetConstMacro(OutsideValue, ScalarType);
 
   //##Description
   //## @brief If set to \a true the minimum of the ouput pixel type is
   //## used as outside value (default: \a false)
   itkSetMacro(AutoOutsideValue, bool);
   itkGetConstMacro(AutoOutsideValue, bool);
   itkBooleanMacro(AutoOutsideValue);
 
   itkSetMacro(AutoOrientLabels, bool);
   itkGetConstMacro(AutoOrientLabels, bool);
 
   //##Description
   //## @brief If set to \a true both sides of the clipping
   //## geometry will be labeld using m_AboveGeometryLabel and
   //## m_BelowGeometryLabel
   itkSetMacro(LabelBothSides, bool);
   itkGetConstMacro(LabelBothSides, bool);
   itkBooleanMacro(LabelBothSides);
 
   //##Description
   //## @brief Set for voxels above the clipping geometry.
   //## This value is only used, if m_LabelBothSides is set to true.
   itkSetMacro(AboveGeometryLabel, ScalarType);
   itkGetConstMacro(AboveGeometryLabel, ScalarType);
 
   //##Description
   //## @brief Set for voxels below the clipping geometry.
   //## This value is only used, if m_LabelBothSides is set to true.
   itkSetMacro(BelowGeometryLabel, ScalarType);
   itkGetConstMacro(BelowGeometryLabel, ScalarType);
 
   protected:
   GeometryClipImageFilter();
 
   ~GeometryClipImageFilter();
 
   virtual void GenerateInputRequestedRegion();
 
   virtual void GenerateOutputInformation();
 
   virtual void GenerateData();
 
   template < typename TPixel, unsigned int VImageDimension >
-    friend void _InternalComputeClippedImage(itk::Image<TPixel, VImageDimension>* itkImage, mitk::GeometryClipImageFilter* geometryClipper, const mitk::PlaneGeometry* clippingGeometry2D);
+    friend void _InternalComputeClippedImage(itk::Image<TPixel, VImageDimension>* itkImage, mitk::GeometryClipImageFilter* geometryClipper, const mitk::PlaneGeometry* clippingPlaneGeometry);
 
   mitk::BaseGeometry::ConstPointer m_ClippingGeometry;
   mitk::GeometryData::Pointer m_ClippingGeometryData;
   mitk::TimeGeometry::ConstPointer m_TimeClippingGeometry;
   mitk::ImageTimeSelector::Pointer m_InputTimeSelector;
   mitk::ImageTimeSelector::Pointer m_OutputTimeSelector;
 
   //##Description
   //## @brief Defines whether the part above or below the geometry
   //## shall be clipped (default: @a true)
   bool m_ClipPartAboveGeometry;
 
   //##Description
   //## @brief Value for outside pixels (default: 0)
   //##
   //## Used only if m_AutoOutsideValue is \a false.
   ScalarType m_OutsideValue;
   //##Description
   //## @brief If \a true the minimum of the ouput pixel type is
   //## used as outside value (default: \a false)
   bool m_AutoOutsideValue;
 
   //##Description
   //## @brief If \a true all pixels above and below the geometry
   //## are labeled with m_AboveGeometryLabel and m_BelowGeometryLabel
   bool m_LabelBothSides;
 
   /**
    * \brief Orient above like vtkPolyDataNormals does with AutoOrientNormals
    */
   bool m_AutoOrientLabels;
 
   //##Description
   //## @brief Is used for labeling all pixels above the geometry
   //## when m_LabelBothSides is on
   ScalarType m_AboveGeometryLabel;
 
   //##Description
   //## @brief Is used for labeling all pixels below the geometry
   //## when m_LabelBothSides is on
   ScalarType m_BelowGeometryLabel;
 
   //##Description
   //## @brief Time when Header was last initialized
   itk::TimeStamp m_TimeOfHeaderInitialization;
 };
 
 } // namespace mitk
 
 #endif /* MITKGEOMETRYCLIPIMAGEFILTER_H_HEADER_INCLUDED_C1F48A22 */
diff --git a/Modules/ContourModel/DataManagement/mitkContourModel.h b/Modules/ContourModel/DataManagement/mitkContourModel.h
index 5451857e89..78a6f9e50f 100644
--- a/Modules/ContourModel/DataManagement/mitkContourModel.h
+++ b/Modules/ContourModel/DataManagement/mitkContourModel.h
@@ -1,474 +1,474 @@
 /*===================================================================
 
 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_CONTOURMODEL_H_
 #define _MITK_CONTOURMODEL_H_
 
 #include "mitkCommon.h"
 #include <MitkContourModelExports.h>
 #include "mitkBaseData.h"
 
 #include <mitkContourElement.h>
 
 
 namespace mitk
 {
 
   /**
   \brief ContourModel is a structure of linked vertices defining a contour in 3D space.
   The vertices are stored in a mitk::ContourElement is stored for each timestep.
   The contour line segments are implicitly defined by the given linked vertices.
   By default two control points are are linked by a straight line.It is possible to add
   vertices at front and end of the contour and to iterate in both directions.
 
   Points are specified containing coordinates and additional (data) information,
   see mitk::ContourElement.
   For accessing a specific vertex either an index or a position in 3D Space can be used.
   The vertices are best accessed by using a VertexIterator.
   Interaction with the contour is thus available without any mitk interactor class using the
   api of ContourModel. It is possible to shift single vertices also as shifting the whole
   contour.
 
   A contour can be either open like a single curved line segment or
   closed. A closed contour can for example represent a jordan curve.
 
   \section mitkContourModelDisplayOptions Display Options
 
   The default mappers for this data structure are mitk::ContourModelGLMapper2D and
   mitk::ContourModelMapper3D. See these classes for display options which can
   can be set via properties.
   */
   class MitkContourModel_EXPORT ContourModel : public BaseData
   {
 
   public:
 
     mitkClassMacro(ContourModel, BaseData);
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
     typedef mitk::ContourElement::VertexType VertexType;
     typedef mitk::ContourElement::VertexListType VertexListType;
     typedef mitk::ContourElement::VertexIterator VertexIterator;
     typedef mitk::ContourElement::ConstVertexIterator ConstVertexIterator;
     typedef std::vector< mitk::ContourElement::Pointer > ContourModelSeries;
     /*+++++++++++++++ END typedefs ++++++++++++++++++++++++++++*/
 
 
     /** \brief Possible interpolation of the line segments between control points */
     enum LineSegmentInterpolation{
       LINEAR, B_SPLINE
     };
 
 
 
     /*++++++++++++++++  inline methods  +++++++++++++++++++++++*/
 
     /** \brief Get the current selected vertex.
     */
     VertexType* GetSelectedVertex()
     {
       return this->m_SelectedVertex;
     }
 
     /** \brief Deselect vertex.
     */
     void Deselect()
     {
       this->m_SelectedVertex = NULL;
     }
 
     /** \brief Set selected vertex as control point
     */
     void SetSelectedVertexAsControlPoint(bool isControlPoint=true)
     {
       if (this->m_SelectedVertex)
       {
         m_SelectedVertex->IsControlPoint = isControlPoint;
         this->Modified();
       }
     }
 
     /** \brief Set the interpolation of the line segments between control points.
     */
     void SetLineSegmentInterpolation(LineSegmentInterpolation interpolation)
     {
       this->m_lineInterpolation = interpolation;
       this->Modified();
     }
 
     /** \brief Get the interpolation of the line segments between control points.
     */
     LineSegmentInterpolation GetLineSegmentInterpolation()
     {
       return this->m_lineInterpolation;
     }
     /*++++++++++++++++  END inline methods  +++++++++++++++++++++++*/
 
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertex(mitk::Point3D &vertex, int timestep=0);
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertex(VertexType &vertex, int timestep=0);
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeSlicedGeometry will not be expanded.
     */
     void AddVertex(const VertexType* vertex, int timestep=0);
 
     /** \brief Add a vertex to the contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
     \param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
     will be rendered).
 
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep=0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
     The vertex is added at the FRONT of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertexAtFront(mitk::Point3D &vertex, int timestep=0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
     The vertex is added at the FRONT of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertexAtFront(VertexType &vertex, int timestep=0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
     \param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
     will be rendered).
 
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep=0);
 
     /** \brief Insert a vertex at given index.
     */
     void InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint=false, int timestep=0);
 
     /** \brief Set a coordinates for point at given index.
     */
     bool SetVertexAt(int pointId, const mitk::Point3D &point, unsigned int timestep=0);
 
     /** \brief Set a coordinates for point at given index.
     */
     bool SetVertexAt(int pointId, const VertexType* vertex, unsigned int timestep=0);
 
     /** \brief Return if the contour is closed or not.
     */
     bool IsClosed( int timestep=0);
 
     /** \brief Concatenate two contours.
     The starting control point of the other will be added at the end of the contour.
     \pararm timestep - the timestep at which the vertex will be add ( default 0)
     \pararm check - check for intersections ( default false)
     */
     void Concatenate(mitk::ContourModel* other, int timestep=0, bool check=false);
 
     /** \brief Returns a const VertexIterator at the start element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator Begin( int timestep=0);
 
     /** \brief Returns a const VertexIterator at the start element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator IteratorBegin( int timestep=0);
 
     /** \brief Returns a const VertexIterator at the end element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator End( int timestep=0);
 
     /** \brief Returns a const VertexIterator at the end element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator IteratorEnd( int timestep=0);
 
     /** \brief Close the contour.
     The last control point will be linked with the first point.
     */
     virtual void Close( int timestep=0);
 
     /** \brief Set isClosed to false contour.
     The link between the last control point the first point will be removed.
     */
     virtual void Open( int timestep=0);
 
     /** \brief Set closed property to given boolean.
 
     false - The link between the last control point the first point will be removed.
     true - The last control point will be linked with the first point.
     */
     virtual void SetClosed(bool isClosed, int timestep=0);
 
     /** \brief Returns the number of vertices at a given timestep.
     \param timestep - default = 0
     */
     int GetNumberOfVertices( int timestep=0) const;
 
     /** \brief Returns whether the contour model is empty at a given timestep.
     \pararm timestep - default = 0
     */
     virtual bool IsEmpty( int timestep) const;
 
     /** \brief Returns whether the contour model is empty.
     */
     virtual bool IsEmpty() const;
 
     /** \brief Returns the vertex at the index position within the container.
     */
     virtual const VertexType* GetVertexAt(int index, int timestep=0) const;
 
     /** \brief Remove a vertex at given timestep within the container.
 
     \return index of vertex. -1 if not found.
     */
     int GetIndex(const VertexType* vertex, int timestep=0);
 
     /** \brief Check if there isn't something at this timestep.
     */
     virtual bool IsEmptyTimeStep(unsigned int t) const;
 
     /** \brief Check if mouse cursor is near the contour.
     */
     virtual bool IsNearContour(mitk::Point3D &point, float eps, int timestep);
 
     /** \brief Mark a vertex at an index in the container as selected.
     */
     bool SelectVertexAt(int index, int timestep=0);
 
     /** \brief Mark a vertex at an index in the container as control point.
     */
     bool SetControlVertexAt(int index, int timestep=0);
 
     /** \brief Mark a vertex at a given position in 3D space.
 
     \param point - query point in 3D space
     \param eps - radius for nearest neighbour search (error bound).
     \param timestep - search at this timestep
 
     @return true = vertex found;  false = no vertex found
     */
     bool SelectVertexAt(mitk::Point3D &point, float eps, int timestep=0);
 /*
     \pararm point - query point in 3D space
     \pararm eps - radius for nearest neighbour search (error bound).
     \pararm timestep - search at this timestep
 
     @return true = vertex found;  false = no vertex found
     */
     bool SetControlVertexAt(mitk::Point3D &point, float eps, int timestep=0);
 
     /** \brief Remove a vertex at given index within the container.
 
     @return true = the vertex was successfuly removed;  false = wrong index.
     */
     bool RemoveVertexAt(int index, int timestep=0);
 
     /** \brief Remove a vertex at given timestep within the container.
 
     @return true = the vertex was successfuly removed.
     */
     bool RemoveVertex(const VertexType* vertex, int timestep=0);
 
     /** \brief Remove a vertex at a query position in 3D space.
 
     The vertex to be removed will be search by nearest neighbour search.
     Note that possibly no vertex at this position and eps is stored inside
     the contour.
 
     @return true = the vertex was successfuly removed;  false = no vertex found.
     */
     bool RemoveVertexAt(mitk::Point3D &point, float eps, int timestep=0);
 
     /** \brief Shift the currently selected vertex by a translation vector.
 
     \param translate - the translation vector.
     */
     void ShiftSelectedVertex(mitk::Vector3D &translate);
 
     /** \brief Shift the whole contour by a translation vector at given timestep.
 
     \param translate - the translation vector.
     \param timestep - at this timestep the contour will be shifted.
     */
     void ShiftContour(mitk::Vector3D &translate, int timestep=0);
 
     /** \brief Clear the storage container at given timestep.
 
     All control points are removed at
     timestep.
     */
     virtual void Clear(int timestep);
 
     /** \brief Initialize all data objects
     */
     virtual void Initialize();
 
     /** \brief Initialize object with specs of other contour.
     Note: No data will be copied.
     */
     void Initialize(mitk::ContourModel &other);
 
 
     /*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     virtual void SetRequestedRegionToLargestPossibleRegion ();
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion ();
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     virtual bool VerifyRequestedRegion ();
 
     /**
     \brief Get the updated geometry with recomputed bounds.
     */
     virtual const mitk::BaseGeometry* GetUpdatedGeometry (int t=0);
 
     /**
-    \brief Get the Geometry3D for timestep t.
+    \brief Get the BaseGeometry for timestep t.
     */
     virtual mitk::BaseGeometry* GetGeometry (int t=0) const;
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     virtual void SetRequestedRegion( const itk::DataObject *data);
 
     /**
     \brief Expand the timebounds of the TimeGeometry to given number of timesteps.
     */
     virtual void Expand( unsigned int timeSteps );
 
     /**
     \brief Update the OutputInformation of a ContourModel object
 
     The BoundingBox of the contour will be updated, if necessary.
     */
     virtual void UpdateOutputInformation();
 
     /**
     \brief Clear the storage container.
 
     The object is set to initial state. All control points are removed and the number of
     timesteps are set to 1.
     */
     virtual void Clear();
 
     /**
     \brief overwrite if the Data can be called by an Interactor (StateMachine).
     */
     void ExecuteOperation(Operation* operation);
 
     /** \brief Redistributes ontrol vertices with a given period (as number of vertices)
     \param period - the number of vertices between control points.
     \param timestep - at this timestep all lines will be rebuilt.
     */
     virtual void RedistributeControlVertices(int period, int timestep);
 
   protected:
     mitkCloneMacro(Self);
 
     ContourModel();
     ContourModel(const mitk::ContourModel &other);
     virtual ~ContourModel();
 
     //inherit from BaseData. called by Clear()
     virtual void ClearData();
 
     //inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
     virtual void InitializeEmpty();
 
     //Shift a vertex
     void ShiftVertex(VertexType* vertex, mitk::Vector3D &vector);
 
     //Storage with time resolved support.
     ContourModelSeries m_ContourSeries;
 
     //The currently selected vertex.
     VertexType* m_SelectedVertex;
 
     //The interpolation of the line segment between control points.
     LineSegmentInterpolation m_lineInterpolation;
 
     //only update the bounding geometry if necessary
     bool m_UpdateBoundingBox;
   };
 
   itkEventMacro( ContourModelEvent, itk::AnyEvent );
   itkEventMacro( ContourModelShiftEvent, ContourModelEvent );
   itkEventMacro( ContourModelSizeChangeEvent, ContourModelEvent );
   itkEventMacro( ContourModelAddEvent, ContourModelSizeChangeEvent );
   itkEventMacro( ContourModelRemoveEvent, ContourModelSizeChangeEvent );
   itkEventMacro( ContourModelExpandTimeBoundsEvent, ContourModelEvent );
   itkEventMacro( ContourModelClosedEvent, ContourModelEvent );
 
 }
 #endif
diff --git a/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp b/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
index 4edb2fae92..75ad296034 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
@@ -1,392 +1,392 @@
 /*===================================================================
 
 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 <mitkContourModelMapper2D.h>
 
 #include <mitkContourModelSubDivisionFilter.h>
 
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkAppendPolyData.h>
 #include <vtkProperty.h>
 #include <vtkPlane.h>
 #include <vtkCutter.h>
 #include <vtkStripper.h>
 #include <vtkTubeFilter.h>
 #include <vtkSphereSource.h>
 
 
 mitk::ContourModelMapper2D::ContourModelMapper2D()
 {
 }
 
 
 mitk::ContourModelMapper2D::~ContourModelMapper2D()
 {
 }
 
 
 const mitk::ContourModel* mitk::ContourModelMapper2D::GetInput( void )
 {
   //convient way to get the data from the dataNode
   return static_cast< const mitk::ContourModel * >( GetDataNode()->GetData() );
 }
 
 
 vtkProp* mitk::ContourModelMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actor;
 }
 
 
 void mitk::ContourModelMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   /*++ convert the contour to vtkPolyData and set it as input for our mapper ++*/
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::ContourModel* inputContour  = static_cast< mitk::ContourModel* >( GetDataNode()->GetData() );
 
   unsigned int timestep = renderer->GetTimeStep();
 
   //if there's something to be rendered
   if( inputContour->GetNumberOfVertices(timestep) > 0)
   {
     localStorage->m_OutlinePolyData = this->CreateVtkPolyDataFromContour(inputContour, renderer);
   }
 
   this->ApplyContourProperties(renderer);
 
   localStorage->m_Mapper->SetInputData(localStorage->m_OutlinePolyData);
 
 }
 
 
 
 void mitk::ContourModelMapper2D::Update(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible ) return;
 
 
   //check if there is something to be rendered
   mitk::ContourModel* data  = static_cast< mitk::ContourModel*>( GetDataNode()->GetData() );
   if ( data == NULL )
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
     LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   // Check if time step is valid
     const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
     || ( dataTimeGeometry->CountTimeSteps() == 0 )
     || ( !dataTimeGeometry->IsValidTimeStep( renderer->GetTimeStep() ) ) )
   {
     //clear the rendered polydata
     localStorage->m_Mapper->RemoveAllInputs();//SetInput(vtkSmartPointer<vtkPolyData>::New());
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
 
 
   //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 < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
+    || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->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();
 }
 
 
 
 vtkSmartPointer<vtkPolyData> mitk::ContourModelMapper2D::CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour, mitk::BaseRenderer* renderer)
 {
   unsigned int timestep = this->GetTimestep();
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> resultingPolyData = vtkSmartPointer<vtkPolyData>::New();
 
 
   //check for the worldgeometry from the current render window
-  mitk::PlaneGeometry* currentWorldGeometry = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::PlaneGeometry*>(renderer->GetCurrentWorldGeometry2D()));
+  mitk::PlaneGeometry* currentWorldGeometry = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::PlaneGeometry*>(renderer->GetCurrentWorldPlaneGeometry()));
 
   if(currentWorldGeometry)
   {
     //origin and normal of vtkPlane
     mitk::Point3D origin = currentWorldGeometry->GetOrigin();
     mitk::Vector3D normal = currentWorldGeometry->GetNormal();
     //the implicit function to slice through the polyData
     vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
     plane->SetOrigin(origin[0], origin[1], origin[2]);
     plane->SetNormal(normal[0], normal[1], normal[2]);
 
 
     /* First of all convert the control points of the contourModel to vtk points
     * and add lines in between them
     */
     //the points to draw
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     //the lines to connect the points
     vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
     // Create a polydata to store everything in
     vtkSmartPointer<vtkPolyData> polyDataIn3D = vtkSmartPointer<vtkPolyData>::New();
 
 
     vtkSmartPointer<vtkAppendPolyData> appendPoly = vtkSmartPointer<vtkAppendPolyData>::New();
 
     mitk::ContourModel::Pointer renderingContour = mitk::ContourModel::New();
     renderingContour = inputContour;
 
 
 
     bool subdivision = false;
     this->GetDataNode()->GetBoolProperty( "subdivision curve", subdivision, renderer );
     if (subdivision)
     {
 
       mitk::ContourModel::Pointer subdivContour = mitk::ContourModel::New();
 
       mitk::ContourModelSubDivisionFilter::Pointer subdivFilter = mitk::ContourModelSubDivisionFilter::New();
 
       subdivFilter->SetInput(inputContour);
       subdivFilter->Update();
 
       subdivContour = subdivFilter->GetOutput();
 
       if(subdivContour->GetNumberOfVertices() == 0 )
       {
         subdivContour = inputContour;
       }
 
       renderingContour = subdivContour;
     }
 
 
     //iterate over all control points
     mitk::ContourModel::VertexIterator current = renderingContour->IteratorBegin(timestep);
     mitk::ContourModel::VertexIterator next = renderingContour->IteratorBegin(timestep);
     if(next != renderingContour->IteratorEnd(timestep))
     {
       next++;
 
       mitk::ContourModel::VertexIterator end = renderingContour->IteratorEnd(timestep);
 
       while(next != end)
       {
         mitk::ContourModel::VertexType* currentControlPoint = *current;
         mitk::ContourModel::VertexType* nextControlPoint = *next;
 
         vtkIdType p1 = points->InsertNextPoint(currentControlPoint->Coordinates[0], currentControlPoint->Coordinates[1], currentControlPoint->Coordinates[2]);
         vtkIdType p2 = points->InsertNextPoint(nextControlPoint->Coordinates[0], nextControlPoint->Coordinates[1], nextControlPoint->Coordinates[2]);
         //add the line between both contorlPoints
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
 
         if ( currentControlPoint->IsControlPoint )
         {
           double coordinates[3];
           coordinates[0] = currentControlPoint->Coordinates[0];
           coordinates[1] = currentControlPoint->Coordinates[1];
           coordinates[2] = currentControlPoint->Coordinates[2];
 
           double distance = plane->DistanceToPlane(coordinates);
           if(distance < 0.1)
           {
             vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
 
             sphere->SetRadius(1.2);
             sphere->SetCenter(coordinates[0], coordinates[1], coordinates[2]);
             sphere->Update();
             appendPoly->AddInputConnection(sphere->GetOutputPort());
           }
         }
 
 
         current++;
         next++;
       }//end while (it!=end)
 
       //check if last control point is enabled to draw it
       if ( (*current)->IsControlPoint )
       {
         double coordinates[3];
         coordinates[0] = (*current)->Coordinates[0];
         coordinates[1] = (*current)->Coordinates[1];
         coordinates[2] = (*current)->Coordinates[2];
 
         double distance = plane->DistanceToPlane(coordinates);
         if(distance < 0.1)
         {
           vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
 
           sphere->SetRadius(1.2);
           sphere->SetCenter(coordinates[0], coordinates[1], coordinates[2]);
           sphere->Update();
           appendPoly->AddInputConnection(sphere->GetOutputPort());
         }
       }
 
 
       /* If the contour is closed an additional line has to be created between the very first point
       * and the last point
       */
       if(renderingContour->IsClosed(timestep))
       {
         //add a line from the last to the first control point
         mitk::ContourModel::VertexType* firstControlPoint = *(renderingContour->IteratorBegin(timestep));
         mitk::ContourModel::VertexType* lastControlPoint = *(--(renderingContour->IteratorEnd(timestep)));
         vtkIdType p2 = points->InsertNextPoint(lastControlPoint->Coordinates[0], lastControlPoint->Coordinates[1], lastControlPoint->Coordinates[2]);
         vtkIdType p1 = points->InsertNextPoint(firstControlPoint->Coordinates[0], firstControlPoint->Coordinates[1], firstControlPoint->Coordinates[2]);
 
         //add the line between both contorlPoints
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }//end if(isClosed)
 
 
       // Add the points to the dataset
       polyDataIn3D->SetPoints(points);
       // Add the lines to the dataset
       polyDataIn3D->SetLines(lines);
 
 
 
 
       //cut through polyData
       bool useCuttingPlane = false;
       this->GetDataNode()->GetBoolProperty( "use cutting plane", useCuttingPlane, renderer );
       if (useCuttingPlane)
       {
         //slice through the data to get a 2D representation of the (possible) 3D contour
 
         //needed because currently there is no outher solution if the contour is within the plane
         vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
         tubeFilter->SetInputData(polyDataIn3D);
         tubeFilter->SetRadius(0.05);
 
 
         //cuts through vtkPolyData with a given implicit function. In our case a plane
         vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
 
         cutter->SetCutFunction(plane);
 
         cutter->SetInputConnection(tubeFilter->GetOutputPort());
 
         //we want the scalars of the input - so turn off generating the scalars within vtkCutter
         cutter->GenerateCutScalarsOff();
         cutter->Update();
 
 
         //set to 2D representation of the contour
         resultingPolyData= cutter->GetOutput();
 
       }//end if(project contour)
       else
       {
         //set to 3D polyData
         resultingPolyData = polyDataIn3D;
       }
 
     }//end if (it != end)
 
     appendPoly->AddInputData(resultingPolyData);
     appendPoly->Update();
 
     //return contour with control points
     return appendPoly->GetOutput();
   }else
   {
     //return empty polyData
     return resultingPolyData;
   }
 }
 
 
 
 void mitk::ContourModelMapper2D::ApplyContourProperties(mitk::BaseRenderer* renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float lineWidth(1.0);
   if (this->GetDataNode()->GetFloatProperty( "width", lineWidth, renderer ))
   {
     localStorage->m_Actor->GetProperty()->SetLineWidth(lineWidth);
   }
 
   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("color", renderer));
   if(colorprop)
   {
     //set the color of the contour
     double red = colorprop->GetColor().GetRed();
     double green = colorprop->GetColor().GetGreen();
     double blue = colorprop->GetColor().GetBlue();
     localStorage->m_Actor->GetProperty()->SetColor(red, green, blue);
   }
 
 
   //make sure that directional lighting isn't used for our contour
   localStorage->m_Actor->GetProperty()->SetAmbient(1.0);
   localStorage->m_Actor->GetProperty()->SetDiffuse(0.0);
   localStorage->m_Actor->GetProperty()->SetSpecular(0.0);
 }
 
 
 /*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
 
 mitk::ContourModelMapper2D::LocalStorage* mitk::ContourModelMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 
 mitk::ContourModelMapper2D::LocalStorage::LocalStorage()
 {
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
 
   //set the mapper for the actor
   m_Actor->SetMapper(m_Mapper);
 }
 
 
 void mitk::ContourModelMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite );
   node->AddProperty( "width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
   node->AddProperty( "use cutting plane", mitk::BoolProperty::New( true ), renderer, overwrite );
   node->AddProperty( "subdivision curve", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp b/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
index a38fe8ee8f..8607d7e97e 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
@@ -1,243 +1,243 @@
 /*===================================================================
 
 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 <mitkContourModelMapper3D.h>
 
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkProperty.h>
 
 mitk::ContourModelMapper3D::ContourModelMapper3D()
 {
 }
 
 
 mitk::ContourModelMapper3D::~ContourModelMapper3D()
 {
 }
 
 
 const mitk::ContourModel* mitk::ContourModelMapper3D::GetInput( void )
 {
   //convient way to get the data from the dataNode
   return static_cast< const mitk::ContourModel * >( GetDataNode()->GetData() );
 }
 
 
 vtkProp* mitk::ContourModelMapper3D::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actor;
 }
 
 
 void mitk::ContourModelMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   /* First convert the contourModel to vtkPolyData, then tube filter it and
    * set it input for our mapper
    */
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::ContourModel* inputContour  = static_cast< mitk::ContourModel* >( GetDataNode()->GetData() );
 
   localStorage->m_OutlinePolyData = this->CreateVtkPolyDataFromContour(inputContour);
 
   this->ApplyContourProperties(renderer);
 
   //tube filter the polyData
   localStorage->m_TubeFilter->SetInputData(localStorage->m_OutlinePolyData);
 
   float lineWidth(1.0);
   if (this->GetDataNode()->GetFloatProperty( "contour.3D.width", lineWidth, renderer ))
   {
     localStorage->m_TubeFilter->SetRadius(lineWidth);
   }else
   {
     localStorage->m_TubeFilter->SetRadius(0.5);
   }
   localStorage->m_TubeFilter->CappingOn();
   localStorage->m_TubeFilter->SetNumberOfSides(10);
   localStorage->m_TubeFilter->Update();
   localStorage->m_Mapper->SetInputConnection(localStorage->m_TubeFilter->GetOutputPort());
 
 }
 
 
 
 void mitk::ContourModelMapper3D::Update(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
 
   mitk::ContourModel* data  = static_cast< mitk::ContourModel*>( GetDataNode()->GetData() );
   if ( data == NULL )
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
     || ( dataTimeGeometry->CountTimeSteps() == 0 )
     || ( !dataTimeGeometry->IsValidTimeStep( renderer->GetTimeStep() ) )
     || ( this->GetTimestep() == -1 ) )
   {
     //clear the rendered polydata
     localStorage->m_Mapper->SetInputData(vtkSmartPointer<vtkPolyData>::New());
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
 
   //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 < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
+    || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->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();
 }
 
 
 
 vtkSmartPointer<vtkPolyData> mitk::ContourModelMapper3D::CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour)
 {
   unsigned int timestep = this->GetTimestep();
 
   //the points to draw
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   //the lines to connect the points
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
 
   //iterate over the control points
   mitk::ContourModel::VertexIterator current = inputContour->IteratorBegin(timestep);
   mitk::ContourModel::VertexIterator next = inputContour->IteratorBegin(timestep);
   if(next != inputContour->IteratorEnd(timestep))
   {
     next++;
 
     mitk::ContourModel::VertexIterator end = inputContour->IteratorEnd(timestep);
 
     while(next != end)
     {
       mitk::ContourModel::VertexType* currentControlPoint = *current;
       mitk::ContourModel::VertexType* nextControlPoint = *next;
 
       if( !(currentControlPoint->Coordinates[0] == nextControlPoint->Coordinates[0] &&
           currentControlPoint->Coordinates[1] == nextControlPoint->Coordinates[1] &&
           currentControlPoint->Coordinates[2] == nextControlPoint->Coordinates[2]))
       {
         vtkIdType p1 = points->InsertNextPoint(currentControlPoint->Coordinates[0], currentControlPoint->Coordinates[1], currentControlPoint->Coordinates[2]);
         vtkIdType p2 = points->InsertNextPoint(nextControlPoint->Coordinates[0], nextControlPoint->Coordinates[1], nextControlPoint->Coordinates[2]);
         //add the line between both contorlPoints
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
       current++;
       next++;
     }
 
     if(inputContour->IsClosed(timestep))
     {
       // If the contour is closed add a line from the last to the first control point
       mitk::ContourModel::VertexType* firstControlPoint = *(inputContour->IteratorBegin(timestep));
       mitk::ContourModel::VertexType* lastControlPoint = *(--(inputContour->IteratorEnd(timestep)));
       if( lastControlPoint->Coordinates[0] != firstControlPoint->Coordinates[0] ||
           lastControlPoint->Coordinates[1] != firstControlPoint->Coordinates[1] ||
           lastControlPoint->Coordinates[2] != firstControlPoint->Coordinates[2])
       {
         vtkIdType p2 = points->InsertNextPoint(lastControlPoint->Coordinates[0], lastControlPoint->Coordinates[1], lastControlPoint->Coordinates[2]);
         vtkIdType p1 = points->InsertNextPoint(firstControlPoint->Coordinates[0], firstControlPoint->Coordinates[1], firstControlPoint->Coordinates[2]);
 
         //add the line to the cellArray
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
     }
 
 
     // Add the points to the dataset
     polyData->SetPoints(points);
     // Add the lines to the dataset
     polyData->SetLines(lines);
   }
   return polyData;
 }
 
 
 
 void mitk::ContourModelMapper3D::ApplyContourProperties(mitk::BaseRenderer* renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
 
   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
         ("contour.color", renderer));
   if(colorprop)
   {
     //set the color of the contour
     double red = colorprop->GetColor().GetRed();
     double green = colorprop->GetColor().GetGreen();
     double blue = colorprop->GetColor().GetBlue();
     localStorage->m_Actor->GetProperty()->SetColor(red, green, blue);
   }
 }
 
 
 /*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
 
 mitk::ContourModelMapper3D::LocalStorage* mitk::ContourModelMapper3D::GetLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 
 mitk::ContourModelMapper3D::LocalStorage::LocalStorage()
 {
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_TubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
 
   //set the mapper for the actor
   m_Actor->SetMapper(m_Mapper);
 }
 
 
 void mitk::ContourModelMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
   node->AddProperty( "contour.3D.width", mitk::FloatProperty::New( 0.5 ), renderer, overwrite );
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
index 5de27d6f60..5c2a4dc5df 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
@@ -1,206 +1,206 @@
 /*===================================================================
 
 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 <mitkContourModelSetMapper3D.h>
 
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkProperty.h>
 #include "mitkSurface.h"
 
 mitk::ContourModelSetMapper3D::ContourModelSetMapper3D()
 {
 }
 
 
 mitk::ContourModelSetMapper3D::~ContourModelSetMapper3D()
 {
 }
 
 
 const mitk::ContourModelSet* mitk::ContourModelSetMapper3D::GetInput( void )
 {
   //convient way to get the data from the dataNode
   return static_cast< const mitk::ContourModelSet * >( GetDataNode()->GetData() );
 }
 
 
 vtkProp* mitk::ContourModelSetMapper3D::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Assembly;
 }
 
 
 void mitk::ContourModelSetMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   /* First convert the contourModel to vtkPolyData, then tube filter it and
    * set it input for our mapper
    */
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::ContourModelSet* contourSet = static_cast< mitk::ContourModelSet* >( GetDataNode()->GetData() );
 
   mitk::ContourModelSet::ContourModelSetIterator it = contourSet->Begin();
   mitk::ContourModelSet::ContourModelSetIterator end = contourSet->End();
 
   while(it!=end)
   {
     mitk::ContourModel* inputContour  = it->GetPointer();
     vtkSmartPointer<vtkPolyData> polyData = this->CreateVtkPolyDataFromContour(inputContour, renderer);
 
     vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
     tubeFilter->SetInputData(polyData);
 
     float lineWidth(1.0);
     if (this->GetDataNode()->GetFloatProperty( "contour.3D.width", lineWidth, renderer ))
     {
       tubeFilter->SetRadius(lineWidth);
     }else
     {
       tubeFilter->SetRadius(0.5);
     }
     tubeFilter->CappingOn();
     tubeFilter->SetNumberOfSides(10);
     tubeFilter->Update();
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
 
     mapper->SetInputConnection(tubeFilter->GetOutputPort());
     //mapper->SetInput(polyData);
 
     localStorage->m_Assembly->AddPart(actor);
 
     ++it;
   }
 
 
   this->ApplyContourProperties(renderer);
 
 }
 
 
 
 void mitk::ContourModelSetMapper3D::Update(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
 
   mitk::ContourModel* data  = static_cast< mitk::ContourModel*>( GetDataNode()->GetData() );
   if ( data == NULL )
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   if ( this->GetTimestep() == -1 )
   {
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
 
   //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 < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
+    || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->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();
 }
 
 
 
 vtkSmartPointer<vtkPolyData> mitk::ContourModelSetMapper3D::CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour, mitk::BaseRenderer* renderer)
 {
   unsigned int timestep = this->GetTimestep();
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   localStorage->m_contourToPolyData->SetInput(inputContour);
   localStorage->m_contourToPolyData->Update();
 
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData = localStorage->m_contourToPolyData->GetOutput()->GetVtkPolyData(timestep);
 
   return polyData;
 }
 
 
 
 void mitk::ContourModelSetMapper3D::ApplyContourProperties(mitk::BaseRenderer* renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
 
   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
         ("contour.color", renderer));
   if(colorprop)
   {
     //set the color of the contour
     double red = colorprop->GetColor().GetRed();
     double green = colorprop->GetColor().GetGreen();
     double blue = colorprop->GetColor().GetBlue();
 
 
     vtkSmartPointer<vtkPropCollection> collection = vtkSmartPointer<vtkPropCollection>::New();
     localStorage->m_Assembly->GetActors(collection);
     collection->InitTraversal();
     for(vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
     {
       vtkActor::SafeDownCast(collection->GetNextProp())->GetProperty()->SetColor(red, green, blue);
     }
   }
 }
 
 
 /*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
 
 mitk::ContourModelSetMapper3D::LocalStorage* mitk::ContourModelSetMapper3D::GetLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 
 mitk::ContourModelSetMapper3D::LocalStorage::LocalStorage()
 {
   m_Assembly = vtkSmartPointer<vtkAssembly>::New();
   m_contourToPolyData = mitk::ContourModelToSurfaceFilter::New();
 }
 
 
 void mitk::ContourModelSetMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
   node->AddProperty( "contour.3D.width", mitk::FloatProperty::New( 0.5 ), renderer, overwrite );
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Modules/Ext/Algorithms/mitkAngleCorrectByPointFilter.cpp b/Modules/Ext/Algorithms/mitkAngleCorrectByPointFilter.cpp
index 2a3acd2591..3aa3dc0ee5 100644
--- a/Modules/Ext/Algorithms/mitkAngleCorrectByPointFilter.cpp
+++ b/Modules/Ext/Algorithms/mitkAngleCorrectByPointFilter.cpp
@@ -1,228 +1,228 @@
 /*===================================================================
 
 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 "mitkAngleCorrectByPointFilter.h"
 #include "mitkIpPic.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 #include "mitkImageReadAccessor.h"
 #include <mitkProportionalTimeGeometry.h>
 
 mitk::AngleCorrectByPointFilter::AngleCorrectByPointFilter() : m_PreferTransducerPositionFromProperty(true)
 {
   m_Center.Fill(0);
   m_TransducerPosition.Fill(0);
 }
 
 mitk::AngleCorrectByPointFilter::~AngleCorrectByPointFilter()
 {
 
 }
 
 void mitk::AngleCorrectByPointFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   unsigned int i;
   unsigned int *tmpDimensions = new unsigned int[input->GetDimension()];
 
   for(i=0;i<input->GetDimension();++i)
     tmpDimensions[i]=input->GetDimension(i);
 
   //@todo maybe we should shift the following somehow in ImageToImageFilter
   mitk::PixelType scalarPType = MakeScalarPixelType<ScalarType>();
   output->Initialize(scalarPType,
     input->GetDimension(),
     tmpDimensions,
     input->GetNumberOfChannels());
 
   output->GetSlicedGeometry()->SetSpacing(input->GetSlicedGeometry()->GetSpacing());
 
-  //output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
+  //output->GetSlicedGeometry()->SetPlaneGeometry(mitk::Image::BuildStandardPlanePlaneGeometry(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
   //output->GetSlicedGeometry()->SetEvenlySpaced();
-  //set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
+  //set the timebounds - after SetPlaneGeometry, so that the already created PlaneGeometry will also receive this timebounds.
   //@fixme!!! will not work for not evenly timed data!
   output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
 
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(output->GetSlicedGeometry(),  output->GetTimeGeometry()->CountTimeSteps());
   output->SetTimeGeometry(timeGeometry);
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
 
   delete [] tmpDimensions;
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void mitk::AngleCorrectByPointFilter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
 
   if(m_PreferTransducerPositionFromProperty)
   {
     mitk::Point3iProperty::Pointer pointProp;
     pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
     if (pointProp.IsNotNull() )
     {
       const itk::Point<int, 3> & p = pointProp->GetValue();
       m_TransducerPosition[0] = p[0];
       m_TransducerPosition[1] = p[1];
       m_TransducerPosition[2] = p[2];
     }
   }
 
   itkDebugMacro( << "compute angle corrected image .... " );
   itkDebugMacro( << "  Center[0]=" << m_Center[0] << " Center[1]=" << m_Center[1] << " Center[2]=" << m_Center[2] );
   itkDebugMacro( << "  TransducerPosition[0]=" << m_TransducerPosition[0] << " TransducerPosition[1]=" << m_TransducerPosition[1] << " TransducerPosition[2]=" << m_TransducerPosition[2] );
 
   const Vector3D & spacing = input->GetSlicedGeometry()->GetSpacing();
   //  MITK_INFO << "   in: xres=" << spacing[0] << " yres=" << spacing[1] << " zres=" << spacing[2] << std::endl;
 
   if((spacing[0]!=spacing[1]) || (spacing[0]!=spacing[2]))
   {
     itkExceptionMacro("filter does not work for uninsotropic data: spacing: ("<< spacing[0] << "," << spacing[1] << "," << spacing[2] << ")");
   }
 
   Vector3D p;
   Vector3D tx_direction;
   Vector3D tx_position = m_TransducerPosition.GetVectorFromOrigin();
   Vector3D center = m_Center.GetVectorFromOrigin();
   Vector3D assumed_direction;
   ScalarType &x=p[0];
   ScalarType &y=p[1];
   ScalarType &z=p[2];
   Vector3D down;
   FillVector3D(down,0.0,0.0,-1.0);
 
   int xDim = input->GetDimension(0);
   int yDim = input->GetDimension(1);
   int zDim = input->GetDimension(2);
 
   mitkIpPicDescriptor* pic_out;
   pic_out = mitkIpPicNew();
   pic_out->dim = 3;
   pic_out->bpe  = output->GetPixelType().GetBpe();
   //pic_out->type = output->GetPixelType().GetType();
   pic_out->n[0] = xDim;
   pic_out->n[1] = yDim;
   pic_out->n[2] = zDim;
   pic_out->data = malloc(_mitkIpPicSize(pic_out));
 
   //go!
   mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
   timeSelector->SetInput(input);
 
   int nstart, nmax;
   int tstart, tmax;
 
   tstart=output->GetRequestedRegion().GetIndex(3);
   nstart=output->GetRequestedRegion().GetIndex(4);
 
   tmax=tstart+output->GetRequestedRegion().GetSize(3);
   nmax=nstart+output->GetRequestedRegion().GetSize(4);
 
   int n,t;
   for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n)
   {
     timeSelector->SetChannelNr(n);
 
     for(t=tstart;t<tmax;++t)
     {
       timeSelector->SetTimeNr(t);
 
       timeSelector->Update();
 
       typedef unsigned char InputImagePixelType;
       typedef ScalarType OutputImagePixelType;
 
       if(input->GetPixelType().GetPixelType() != itk::ImageIOBase::SCALAR ||
          input->GetPixelType().GetComponentType()!= MapPixelComponentType<InputImagePixelType>::value)
       {
         itkExceptionMacro("only implemented for " << typeid(PixelType).name() );
       }
 
       InputImagePixelType *in;
       OutputImagePixelType *out;
 
       mitk::ImageReadAccessor tsOutAcc(timeSelector->GetOutput());
       in  = (InputImagePixelType *)tsOutAcc.GetData();
       out = (OutputImagePixelType*)pic_out->data;
 
       for (z=0 ; z<zDim ; ++z)
       {
         for (y=0; y<yDim; ++y)
         {
           for (x=0; x<xDim; ++x, ++in, ++out)
           {
             tx_direction = tx_position-p;
             tx_direction.Normalize();
 
             //are we within the acquisition cone?
 //            if(-tx_direction*down>vnl_math::pi_over_4)
             {
               assumed_direction = center-p;
               assumed_direction.Normalize();
               ScalarType cos_factor = tx_direction*assumed_direction;
 
               if(fabs(cos_factor)>eps)
                 *out=((ScalarType)(*in)-128.0)/cos_factor;
               else
                 *out=((ScalarType)(*in)-128.0)/eps;
             }
             //else
             //  *out=0;
           }
         }
       }
       //output->SetPicVolume(pic_out, t, n);
     }
   }
 }
 
 void mitk::AngleCorrectByPointFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::ImageToImageFilter::InputImagePointer input =
     const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
   mitk::Image::Pointer output = this->GetOutput();
 
   Image::RegionType requestedRegion;
   requestedRegion = output->GetRequestedRegion();
   requestedRegion.SetIndex(0, 0);
   requestedRegion.SetIndex(1, 0);
   requestedRegion.SetIndex(2, 0);
   //requestedRegion.SetIndex(3, 0);
   //requestedRegion.SetIndex(4, 0);
   requestedRegion.SetSize(0, input->GetDimension(0));
   requestedRegion.SetSize(1, input->GetDimension(1));
   requestedRegion.SetSize(2, input->GetDimension(2));
   //requestedRegion.SetSize(3, output->GetDimension(3));
   //requestedRegion.SetSize(4, output->GetNumberOfChannels());
 
   input->SetRequestedRegion( & requestedRegion );
 }
diff --git a/Modules/Ext/Algorithms/mitkCylindricToCartesianFilter.cpp b/Modules/Ext/Algorithms/mitkCylindricToCartesianFilter.cpp
index 3f2ed9cf33..25333af8fc 100644
--- a/Modules/Ext/Algorithms/mitkCylindricToCartesianFilter.cpp
+++ b/Modules/Ext/Algorithms/mitkCylindricToCartesianFilter.cpp
@@ -1,501 +1,501 @@
 /*===================================================================
 
 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 "mitkCylindricToCartesianFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 
 #include "mitkLegacyAdaptors.h"
 #include <mitkIpPicTypeMultiplex.h>
 #include <mitkProportionalTimeGeometry.h>
 
 template <class T>
 void _transform(mitkIpPicDescriptor *pic, mitkIpPicDescriptor *dest, float _outsideValue, float *fr, float *fphi, float *fz, short *rt, unsigned int *phit, unsigned int *zt, mitkIpPicDescriptor *coneCutOff_pic)  //...t=truncated
 {
   T outsideValue = static_cast<T>(_outsideValue);
   register float f, ft, f0, f1, f2, f3;
 
   mitkIpInt2_t ox_size;
   mitkIpInt2_t nx_size, ny_size, nz_size;
   int oxy_size, nxy_size;
 
   T* orig, *dp, *dest_start;
 
   mitkIpInt2_t* coneCutOff=(mitkIpInt2_t*)coneCutOff_pic->data;
 
   orig=(T*)pic->data;
   ox_size=pic->n[0];
   oxy_size=ox_size*pic->n[1];
 
   nx_size=dest->n[0];
   ny_size=dest->n[1];
   nxy_size=nx_size*ny_size;
   nz_size=dest->n[2];
 
   /*nx_size=360;
   ny_size=360;
   nxy_size=nx_size*ny_size;
   nz_size=256;*/
 
   dest_start=dp=((T*)dest->data)+nxy_size*(nz_size-1);
 
   mitkIpInt2_t y;
   //  int size=_mitkIpPicElements(pic);
 
   register mitkIpInt2_t x,z;
   for(y=0;y<ny_size;++y)
   {
     mitkIpInt2_t x_start;
     register mitkIpInt2_t x_end;
     int r0plusphi0=*rt;
     if(r0plusphi0>=0)
     {
       x_start=0; x_end=nx_size;
     }
     else
     {
       x_start=-r0plusphi0; x_end=nx_size+r0plusphi0;
 
       for(z=0;z<nz_size;++z,dp+=-nxy_size-x_start)
         for(x=0;x<x_start;++x,++dp)
           *dp=outsideValue;
       dp+=nxy_size*nz_size; dp+=x_end;
       for(z=0;z<nz_size;++z,dp+=-nxy_size-x_start)
         for(x=x_end;x<nx_size;++x,++dp)
           *dp=outsideValue;
       dp+=nxy_size*nz_size; dp-=x_end;
 
       fr+=x_start;
       fphi+=x_start;
       rt+=x_start;
       phit+=x_start;
       dp+=x_start;
       coneCutOff+=x_start;
     }
 
     for(x=x_start;x<x_end;++x, ++fr, ++fphi, ++rt, ++phit, ++dp, ++coneCutOff)
     {
       f=*fr;
       f3=*fphi;
       f0=1-f;
       f1=1-f3;
       f2=f0*f3;
       f0*=f1;
       f1*=f;
       f3*=f;
 
       r0plusphi0=*rt+*phit;
 
       mitkIpInt2_t z_start;
 
       z_start=*coneCutOff;
 
       T *op;
       register unsigned int step;
       unsigned int *ztp;
 
       op=orig+*rt+*phit;
 
       float *fzp;
 
       for(z=0;z<z_start;++z, dp-=nxy_size)
         *dp=outsideValue;
 
       ztp=zt+z_start;
       fzp=fz+z_start;
 
       for(z=z_start;z<nz_size;++z, dp-=nxy_size)
       {
         step=*(ztp++);
 
         register T *opt=op;
         opt+=step;
         f =*opt*f0;  ++opt;
         f+=*opt*f1;  opt+=oxy_size; --opt;
         f+=*opt*f2;  ++opt;
         f+=*opt*f3;  opt-=oxy_size; --opt;
 
         opt+=ox_size;
         ft =*opt*f0;  ++opt;
         ft+=*opt*f1;  opt+=oxy_size; --opt;
         ft+=*opt*f2;  ++opt;
         ft+=*opt*f3;
 
         *dp=(T)((1-*fzp)*f+*fzp*ft+0.5);
       }
 
       dp+=nxy_size*nz_size;
     }
     fr+=nx_size-x_end;
     fphi+=nx_size-x_end;
     rt+=nx_size-x_end;
     phit+=nx_size-x_end;
     dp+=nx_size-x_end;
     coneCutOff+=nx_size-x_end;
   }
 }
 
 void mitk::CylindricToCartesianFilter::buildTransformShortCuts(int orig_xsize, int orig_ysize, int orig_zsize, int new_xsize, mitkIpPicDescriptor * &rt_pic, mitkIpPicDescriptor * &phit_pic, mitkIpPicDescriptor * &fr_pic, mitkIpPicDescriptor * &fphi_pic, unsigned int * &zt, float * &fz)
 {
   --orig_zsize;
 
   rt_pic=mitkIpPicNew();
   rt_pic->type=mitkIpPicInt;
   rt_pic->bpe=16;
   rt_pic->dim=2;
   rt_pic->n[0]=rt_pic->n[1]=new_xsize;
   rt_pic->data=malloc(_mitkIpPicSize(rt_pic));
 
   phit_pic=mitkIpPicNew();
   phit_pic->type=mitkIpPicUInt;
   phit_pic->bpe=32;
   phit_pic->dim=2;
   phit_pic->n[0]=phit_pic->n[1]=new_xsize;
   phit_pic->data=malloc(_mitkIpPicSize(phit_pic));
 
   fr_pic=mitkIpPicNew();
   fr_pic->type=mitkIpPicFloat;
   fr_pic->bpe=32;
   fr_pic->dim=2;
   fr_pic->n[0]=fr_pic->n[1]=new_xsize;
   fr_pic->data=malloc(_mitkIpPicSize(fr_pic));
 
   fphi_pic=mitkIpPicNew();
   fphi_pic->type=mitkIpPicFloat;
   fphi_pic->bpe=32;
   fphi_pic->dim=2;
   fphi_pic->n[0]=fphi_pic->n[1]=new_xsize;
   fphi_pic->data=malloc(_mitkIpPicSize(fphi_pic));
 
   mitkIpInt2_t  *rtp=(mitkIpInt2_t*)rt_pic->data, *rt_xzero, rt, phit;
   mitkIpUInt4_t  *phitp=(mitkIpUInt4_t*)phit_pic->data;
   mitkIpFloat4_t *fr=(mitkIpFloat4_t *)fr_pic->data;
   mitkIpFloat4_t *fphi=(mitkIpFloat4_t *)fphi_pic->data;
 
   mitkIpFloat4_t r, phi, scale=(double)orig_xsize/(double)new_xsize;
 
   int x,y,xy0,xy0_orig, oxy_size, new_zsize;
   oxy_size=orig_xsize*orig_ysize;
   xy0=(int)(((double)new_xsize)/2+0.5);
   xy0_orig=(int)(((double)orig_xsize)/2+0.5);
 
   new_zsize=(int)(orig_ysize/scale);
   // \bug y compared to x
   for(y=0;y<new_xsize;++y)
   {
     rt_xzero=rtp; *rtp=0;
     for(x=0;x<new_xsize;++x,++fr,++fphi,++rtp, ++phitp)
     {
       int xq=x-xy0, yq=y-xy0;
 
       r=sqrt( (double) (xq*xq+yq*yq));
 
       //      float rtest=-(xy0-sqrt(xy0*xy0-yq*yq))-0.5;
       rt=(mitkIpInt2_t)(-(xy0-sqrt((double) (xy0*xy0-yq*yq)))-0.5);/*in rt steht der Index des Endes der zu �berspringenden Punkte=>anfangen bei -rt+1!*/
       //      if((x>=-rt) && (x<new_xsize+rt))
       {
         if(y!=xy0)
           r=r*(y>xy0?1.0:-1.0)*scale+xy0_orig;
         else
           r=r*(x>xy0?-1.0:1.0)*scale+xy0_orig;
         rt=(mitkIpInt2_t)r;
         int xtmp=x;
         if(x>xy0)
           xtmp=new_xsize-x;
         if(rt<0)
         {
           r=rt=0;
           if(xtmp>-*rt_xzero)
             *rt_xzero=-xtmp;
           *fr=0;
         }
         else
           if(rt>orig_xsize-1)
           {
             r=rt=orig_xsize-1;
             if(xtmp>-*rt_xzero)
               *rt_xzero=-xtmp;
             *fr=0;
           }
           else
             *fr=r-rt;
         if(*fr<0)
           *fr=0;
       }
       //      else
       //        *fr=0;
 
       phi=orig_zsize-(yq==0?1:-atan((float)xq/yq)/M_PI+0.5)*orig_zsize;
       phit=(mitkIpUInt4_t)phi;
       *fphi=phi-phit;
 
       *rtp=rt;
       *phitp=phit*oxy_size;
     }
   }
 
   zt=(unsigned int *)malloc(sizeof(unsigned int)*new_zsize);
   fz=(float *)malloc(sizeof(float)*new_zsize);
 
   float *fzp=fz;
   unsigned int *ztp=zt;
 
   int z;
   float z_step=orig_ysize/(orig_ysize*((float)new_xsize)/orig_xsize);
   for(z=0;z<new_zsize;++z,++fzp,++ztp)
   {
     *fzp=z*z_step;
     *ztp=(unsigned int)*fzp;
     *fzp-=*ztp;
     *ztp*=orig_xsize;
   }
 }
 
 void mitk::CylindricToCartesianFilter::buildConeCutOffShortCut(int orig_xsize, int orig_ysize, mitkIpPicDescriptor *rt_pic, mitkIpPicDescriptor *fr_pic, float a, float b, mitkIpPicDescriptor * &coneCutOff_pic)
 {
   coneCutOff_pic=mitkIpPicNew();
   coneCutOff_pic->type=mitkIpPicInt;
   coneCutOff_pic->bpe=16;
   coneCutOff_pic->dim=2;
   coneCutOff_pic->n[0]=coneCutOff_pic->n[1]=rt_pic->n[0];
   coneCutOff_pic->data=malloc(_mitkIpPicSize(coneCutOff_pic));
 
   int i, size=_mitkIpPicElements(rt_pic);
   mitkIpInt2_t *rt, *ccop, ohx_size, nz_size;
   mitkIpFloat4_t *fr;
 
   a*=(float)rt_pic->n[0]/orig_xsize;
   b*=(float)rt_pic->n[0]/orig_xsize;
 
   ohx_size=orig_xsize/2;
   nz_size=orig_ysize*rt_pic->n[0]/orig_xsize;
 
   rt=(mitkIpInt2_t *)rt_pic->data; fr=(mitkIpFloat4_t*)fr_pic->data; ccop=(mitkIpInt2_t *)coneCutOff_pic->data;
 
   for(i=0; i<size; ++i, ++rt, ++ccop)
   {
     register mitkIpInt2_t cco;
     if(*rt<=ohx_size)
       cco=(mitkIpInt2_t)(a*(*rt+*fr)+b);
     else
       cco=(mitkIpInt2_t)(a*(orig_xsize-(*rt+*fr))+b);
     if(cco<0)
       cco=0;
     if(cco>=nz_size)
       cco=nz_size;
     *ccop=cco;
   }
 }
 
 void mitk::CylindricToCartesianFilter::GenerateOutputInformation()
 {
   mitk::Image::Pointer output = this->GetOutput();
   if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   mitk::Image::ConstPointer input = this->GetInput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   unsigned int i, *tmpDimensions=new unsigned int[std::max(3u,input->GetDimension())];
 
   tmpDimensions[0]=m_TargetXSize;
   if(tmpDimensions[0]==0)
     tmpDimensions[0] = input->GetDimension(0);
 
   float scale=((float)tmpDimensions[0])/input->GetDimension(0);
 
   tmpDimensions[1] = tmpDimensions[0];
   tmpDimensions[2] = (unsigned int)(scale*input->GetDimension(1));
 
   for(i=3;i<input->GetDimension();++i)
     tmpDimensions[i]=input->GetDimension(i);
 
   output->Initialize(input->GetPixelType(),
     input->GetDimension(),
     tmpDimensions,
     input->GetNumberOfChannels());
 
   // initialize the spacing of the output
   Vector3D spacing = input->GetSlicedGeometry()->GetSpacing();
   if(input->GetDimension()>=2)
     spacing[2]=spacing[1];
   else
     spacing[2] = 1.0;
   spacing[1] = spacing[0];
   spacing *= 1.0/scale;
   output->GetSlicedGeometry()->SetSpacing(spacing);
 
   mitk::Point3iProperty::Pointer pointProp;
   pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
   if (pointProp.IsNotNull() )
   {
     itk::Point<int, 3> tp = pointProp->GetValue();
     tp[2] = (int)(tmpDimensions[2]-tp[1] * scale-1);
     tp[0] = tmpDimensions[0]/2;
     tp[1] = tmpDimensions[0]/2;
     mitk::Point3iProperty::Pointer pointProp = mitk::Point3iProperty::New(tp);
     output->SetProperty("ORIGIN", pointProp);
   }
   delete [] tmpDimensions;
 
-  //output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
-  //set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
+  //output->GetSlicedGeometry()->SetPlaneGeometry(mitk::Image::BuildStandardPlanePlaneGeometry(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
+  //set the timebounds - after SetPlaneGeometry, so that the already created PlaneGeometry will also receive this timebounds.
   //@fixme!!! will not work for not evenly timed data!
   output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
 
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(output->GetSlicedGeometry(), output->GetTimeGeometry()->CountTimeSteps());
   output->SetTimeGeometry(timeGeometry);
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void mitk::CylindricToCartesianFilter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
   timeSelector->SetInput(input);
 
   mitkIpPicDescriptor* pic_transformed=NULL;
   pic_transformed = mitkIpPicNew();
   pic_transformed->dim=3;
   pic_transformed->bpe  = output->GetPixelType().GetBpe();
   //pic_transformed->type = output->GetPixelType().GetType();
   pic_transformed->n[0] = output->GetDimension(0);
   pic_transformed->n[1] = output->GetDimension(1);
   pic_transformed->n[2] = output->GetDimension(2);
   pic_transformed->data=malloc(_mitkIpPicSize(pic_transformed));
 
   int nstart, nmax;
   int tstart, tmax;
 
   tstart=output->GetRequestedRegion().GetIndex(3);
   nstart=output->GetRequestedRegion().GetIndex(4);
 
   tmax=tstart+output->GetRequestedRegion().GetSize(3);
   nmax=nstart+output->GetRequestedRegion().GetSize(4);
 
   if(zt==NULL)
   {
     timeSelector->SetChannelNr(nstart);
     timeSelector->SetTimeNr(tstart);
 
     buildTransformShortCuts(input->GetDimension(0),input->GetDimension(1), input->GetDimension(2), output->GetDimension(0), rt_pic, phit_pic, fr_pic, fphi_pic, zt, fz);
 
     // query the line limiting the sector
     a=b=0;
     mitk::FloatProperty::Pointer prop;
 
     prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE SLOPE").GetPointer());
     if (prop.IsNotNull() )
       a = prop->GetValue();
     prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE OFFSET").GetPointer());
     if (prop.IsNotNull() )
       b = prop->GetValue();
 
     buildConeCutOffShortCut(input->GetDimension(0),input->GetDimension(1), rt_pic, fr_pic, a, b, coneCutOff_pic);
     //    mitkIpPicPut("C:\\temp\\rt_90.pic",rt_pic);
     //mitkIpPicPut("C:\\temp\\coneCutOff.pic", coneCutOff_pic);
   }
 
   int n,t;
   for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n)
   {
     timeSelector->SetChannelNr(n);
 
     for(t=tstart;t<tmax;++t)
     {
       timeSelector->SetTimeNr(t);
 
       timeSelector->Update();
 
       // Cast to pic descriptor for the timeSelector image
       mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew();
       mitk::ImageWriteAccessor imageAccess(timeSelector->GetOutput());
       CastToIpPicDescriptor( timeSelector->GetOutput(), &imageAccess, timeSelectorPic );
 
       _mitkIpPicFreeTags(pic_transformed->info->tags_head);
       pic_transformed->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head);
 
       if(input->GetDimension(2)>1)
       {
         mitkIpPicTypeMultiplex9(_transform, timeSelectorPic , pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
         //  mitkIpPicPut("1trf.pic",pic_transformed);
       }
       else
       {
         mitkIpPicDescriptor *doubleSlice = mitkIpPicCopyHeader( timeSelectorPic , NULL);
         doubleSlice->dim=3;
         doubleSlice->n[2]=2;
         doubleSlice->data=malloc(_mitkIpPicSize(doubleSlice));
         memcpy(doubleSlice->data, timeSelectorPic->data, _mitkIpPicSize(doubleSlice)/2);
         mitkIpPicTypeMultiplex9(_transform, doubleSlice, pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
         mitkIpPicFree(doubleSlice);
       }
       output->SetVolume(pic_transformed->data, t, n);
     }
   }
   //mitkIpPicPut("outzzzzzzzz.pic",pic_transformed);
   mitkIpPicFree(pic_transformed);
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 mitk::CylindricToCartesianFilter::CylindricToCartesianFilter()
 : m_OutsideValue(0.0), m_TargetXSize(0)
 {
   rt_pic = NULL; phit_pic = NULL; fr_pic = NULL; fphi_pic = NULL; coneCutOff_pic = NULL;
   zt = NULL; fz = NULL;
   a=b=0.0;
 }
 
 mitk::CylindricToCartesianFilter::~CylindricToCartesianFilter()
 {
   if(rt_pic!=NULL)  mitkIpPicFree(rt_pic);
   if(phit_pic!=NULL)  mitkIpPicFree(phit_pic);
   if(fr_pic!=NULL)  mitkIpPicFree(fr_pic);
   if(fphi_pic!=NULL)  mitkIpPicFree(fphi_pic);
   if(coneCutOff_pic!=NULL)  mitkIpPicFree(coneCutOff_pic);
   if(zt != NULL)  free(zt);
   if(fz != NULL)  free (fz);
 }
 
 void mitk::CylindricToCartesianFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::ImageToImageFilter::InputImagePointer input =
     const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
   mitk::Image::Pointer output = this->GetOutput();
 
   Image::RegionType requestedRegion;
   requestedRegion = output->GetRequestedRegion();
   requestedRegion.SetIndex(0, 0);
   requestedRegion.SetIndex(1, 0);
   requestedRegion.SetIndex(2, 0);
   requestedRegion.SetSize(0, input->GetDimension(0));
   requestedRegion.SetSize(1, input->GetDimension(1));
   requestedRegion.SetSize(2, input->GetDimension(2));
 
   input->SetRequestedRegion( & requestedRegion );
 }
diff --git a/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp b/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp
index c162172885..2f95d42e41 100644
--- a/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp
+++ b/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp
@@ -1,212 +1,212 @@
 /*===================================================================
 
 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 "mitkPlanesPerpendicularToLinesFilter.h"
 
 #include <vnl/vnl_cross.h>
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.txx>
 
 mitk::PlanesPerpendicularToLinesFilter::PlanesPerpendicularToLinesFilter()
   : m_Plane(NULL), m_UseAllPoints(false), m_CreatedGeometries(NULL), normal(3), targetRight(3)
 {
   m_CreatedGeometries = mitk::SlicedGeometry3D::New();
 }
 
 mitk::PlanesPerpendicularToLinesFilter::~PlanesPerpendicularToLinesFilter()
 {
 }
 
 void mitk::PlanesPerpendicularToLinesFilter::GenerateOutputInformation()
 {
   mitk::Mesh::ConstPointer input  = this->GetInput();
   mitk::GeometryData::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   if(input.IsNull()) return;
 
   output->SetGeometry(m_CreatedGeometries);
 }
 
 void mitk::PlanesPerpendicularToLinesFilter::CreatePlane(const mitk::Point3D& curr)
 {
   int j;
   for(j=0;j<3;++j)
     normal[j] = last[j]-curr[j]; //@todo globally define normal direction of display xxx
   normal.normalize();
 
   down = vnl_cross_3d(normal, targetRight);
   down.normalize();
   right = vnl_cross_3d(down, normal);
   right.normalize();
 
   itk2vtk(last.GetVnlVector()-right*halfWidthInMM-down*halfHeightInMM, origin);
   right  *= targetSpacing[0];
   down   *= targetSpacing[1];
   normal *= targetSpacing[2];
 
   mitk::Matrix3D matrix;
   matrix.GetVnlMatrix().set_column(0, right);
   matrix.GetVnlMatrix().set_column(1, down);
   matrix.GetVnlMatrix().set_column(2, normal);
 
   PlaneGeometry::Pointer plane = PlaneGeometry::New();
   plane->GetIndexToWorldTransform()->SetMatrix(matrix);
   plane->SetOrigin(origin);
   plane->SetBounds(bounds);
 
   planes.push_back(plane);
 
   last = curr;
 }
 
 void mitk::PlanesPerpendicularToLinesFilter::GenerateData()
 {
   mitk::Mesh::ConstPointer input  = this->GetInput();
   mitk::GeometryData::Pointer output = this->GetOutput();
 
   if(m_Plane.IsNotNull())
   {
     targetRight   = m_Plane->GetMatrixColumn(0);
     targetSpacing = m_Plane->GetSpacing();
     bounds = m_Plane->GetBoundingBox()->GetBounds();
     halfWidthInMM  = m_Plane->GetExtentInMM(0)*0.5;
     halfHeightInMM = m_Plane->GetExtentInMM(1)*0.5;
   }
   else
   {
     FillVector3D(targetRight, 1.0, 0.0, 0.0);
     targetSpacing.Fill(1.0);
     halfWidthInMM=halfHeightInMM=100.0;
     ScalarType stdBounds[6] = {0.0, 2.0*halfWidthInMM, 0.0, 2.0*halfHeightInMM, 0.0, 0.0};
     bounds = stdBounds;
   }
 
   if(m_UseAllPoints==false)
   {
     int i, size;
     //iterate through all cells and build planes
     Mesh::ConstCellIterator cellIt, cellEnd;
     cellEnd = input->GetMesh()->GetCells()->End();
     for( cellIt = input->GetMesh()->GetCells()->Begin(); cellIt != cellEnd; ++cellIt )
     {
       Mesh::CellType& cell = *cellIt->Value();
 
       Mesh::PointIdIterator ptIt, ptEnd;
       ptEnd = cell.PointIdsEnd();
 
       size=cell.GetNumberOfPoints();
       if(size<=1)
         continue;
 
       ptIt = cell.PointIdsBegin();
       last = input->GetPoint(*ptIt);
       ++ptIt;
       for(i=1;i<size;++i, ++ptIt)
       {
         CreatePlane(input->GetPoint(*ptIt));
       }
     }
   }
   else //m_UseAllPoints==true
   {
     //iterate through all points and build planes
     mitk::PointSet::PointsConstIterator it, pend = input->GetPointSet()->GetPoints()->End();
     it=input->GetPointSet()->GetPoints()->Begin();
     last = it.Value();
     ++it;
     for(;it!=pend;++it)
     {
         CreatePlane(it.Value());
     }
   }
 
   if(planes.size()>0)
   {
     //initialize sliced-geometry for the number of created planes
     m_CreatedGeometries->InitializeSlicedGeometry(planes.size()+1);
 
     //set last plane at last point with same normal as the one before the last
     PlaneGeometry::Pointer plane = static_cast<PlaneGeometry*>((*planes.rbegin())->Clone().GetPointer());
     itk2vtk(last.GetVnlVector()-right*halfWidthInMM-down*halfHeightInMM, origin);
     plane->SetOrigin(origin);
-    m_CreatedGeometries->SetGeometry2D(plane, planes.size());
+    m_CreatedGeometries->SetPlaneGeometry(plane, planes.size());
 
     //add all planes to sliced-geometry
     int s;
     for(s=0; planes.empty()==false; planes.pop_front(), ++s)
     {
-      m_CreatedGeometries->SetGeometry2D(planes.front(), s);
+      m_CreatedGeometries->SetPlaneGeometry(planes.front(), s);
     }
 
     m_CreatedGeometries->SetEvenlySpaced(false);
 
     if(m_FrameGeometry.IsNotNull())
     {
       m_CreatedGeometries->SetIndexToWorldTransform(m_FrameGeometry->GetIndexToWorldTransform());
       m_CreatedGeometries->SetBounds(m_FrameGeometry->GetBounds());
       m_CreatedGeometries->SetReferenceGeometry(m_FrameGeometry);
     }
   }
 
   output->SetGeometry(m_CreatedGeometries);
 }
 
 void mitk::PlanesPerpendicularToLinesFilter::SetPlane(const mitk::PlaneGeometry* aPlane)
 {
   if(aPlane!=NULL)
   {
     m_Plane = static_cast<mitk::PlaneGeometry*>(aPlane->Clone().GetPointer());
   }
   else
   {
     if(m_Plane.IsNull())
       return;
     m_Plane=NULL;
   }
   Modified();
 }
 
 const mitk::Mesh *mitk::PlanesPerpendicularToLinesFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Mesh * >
     (this->ProcessObject::GetInput(0) );
 }
 
 void mitk::PlanesPerpendicularToLinesFilter::SetInput(const mitk::Mesh *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0,
     const_cast< mitk::Mesh * >( input ) );
 }
 
 void mitk::PlanesPerpendicularToLinesFilter::SetFrameGeometry(const mitk::BaseGeometry* frameGeometry)
 {
   if((frameGeometry != NULL) && (frameGeometry->IsValid()))
   {
     m_FrameGeometry = static_cast<mitk::BaseGeometry*>(frameGeometry->Clone().GetPointer());
   }
   else
   {
     m_FrameGeometry = NULL;
   }
 }
diff --git a/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.h b/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.h
index d1238c239b..f213ea24e1 100644
--- a/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.h
+++ b/Modules/Ext/Algorithms/mitkPlanesPerpendicularToLinesFilter.h
@@ -1,145 +1,145 @@
 /*===================================================================
 
 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 MITKPLANESPERPENDICULARTOLINES_H_HEADER_INCLUDED_C10B22CD
 #define MITKPLANESPERPENDICULARTOLINES_H_HEADER_INCLUDED_C10B22CD
 
 #include "mitkGeometryDataSource.h"
 #include "MitkExtExports.h"
 #include "mitkMesh.h"
 #include "mitkGeometryData.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 namespace mitk {
 
 //##Documentation
 //## @brief Create Planes perpendicular to lines contained in a Mesh. The planes data is generated as one SlicedGeometry3D data.
 //## To create the planes as input a
 //## mitk::mesh (for example a pointSet) and as geometry hint a geometry (for example from the original image) must be given.
 //##
 //##  mitk::Mesh::Pointer mesh = mitk::Mesh::New();
 //##  mesh->SetMesh(pointSet->GetPointSet());
 //##  mitk::Image* currentImage = dynamic_cast<mitk::Image*> (myDataStorage->GetNamedNode(IMAGE)->GetData());
 //##  const mitk::Geometry3D* imagegeometry = currentImage->GetUpdatedGeometry();
 //##  mitk::PlanesPerpendicularToLinesFilter::Pointer perpendicularPlanes = mitk::PlanesPerpendicularToLinesFilter::New();
 //##  perpendicularPlanes->SetInput(mesh);
 //##  perpendicularPlanes->SetUseAllPoints(true);
 //##  perpendicularPlanes->SetFrameGeometry(imagegeometry);
 //##  perpendicularPlanes->Update();
 //##
-//## To get one single plane out of these use SlicedGeometry3D->GetGeometry2D(int slicenumber).
+//## To get one single plane out of these use SlicedGeometry3D->GetPlaneGeometry(int slicenumber).
 
 
 
 //## @ingroup Process
 class MitkExt_EXPORT PlanesPerpendicularToLinesFilter : public GeometryDataSource
 {
 public:
   mitkClassMacro(PlanesPerpendicularToLinesFilter, GeometryDataSource);
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   virtual void GenerateOutputInformation();
 
   virtual void GenerateData();
 
   const mitk::Mesh *GetInput(void);
 
   //## @brief Set the input mesh that is used to create the planes.
   virtual void SetInput(const mitk::Mesh *image);
 
   //##Documentation
   //## @brief Set plane to be used as an example of the planes to move
   //## along the lines in the input mesh.
   //##
   //## The size and spacing are copied from the plane. The in-plane
   //## orientation (right-vector) of the created planes are set as
   //## parallel as possible to the orientation (right-vector) of the
   //## the plane set using this method.
   //## @note The PlaneGeometry is cloned, @em not linked/referenced.
   virtual void SetPlane(const mitk::PlaneGeometry* aPlane);
 
   //##Documentation
   //## @brief Set if all points in the mesh should be interpreted as
   //## one long line.
   //##
   //## Cells are not used in this mode, but all points in the order
   //## of their indices form the line.
   //## Default is @a false.
   itkGetConstMacro(UseAllPoints, bool);
 
   //##Documentation
   //## @brief Set if all points of the mesh shall be used (true) or the cells (false)
   //## Default is @a false.
   itkSetMacro(UseAllPoints, bool);
   itkBooleanMacro(UseAllPoints);
 
   //##Documentation
   //## @brief Set an explicit frame of the created sliced geometry
   //##
   //## Set an explicit framegeometry for the created sliced geometry. This framegeometry is
   //## used as geometry for all created planes.
   //## Uses the IndexToWorldTransform and bounding box of the
   //## provided geometry.
   //## \sa CalculateFrameGeometry
   virtual void SetFrameGeometry(const mitk::BaseGeometry* frameGeometry);
 
 protected:
   PlanesPerpendicularToLinesFilter();
 
   virtual ~PlanesPerpendicularToLinesFilter();
 
   //## @brief Creates the plane at point curr
   //##
   //## Creates the plane at point curr. To create this plane, the last point must
   //## must be renowned.
   //## \sa SetPlane
   void CreatePlane(const Point3D& curr);
 
   //## @brief Plane to be used as an example of the planes to move
   //## along the lines in the input mesh.
   //##
   //## The size and spacing are copied from the m_Plane. The in-plane
   //## orientation (right-vector) of the created planes are set as
   //## parallel as possible to the orientation (right-vector) of m_Plane.
   //## \sa SetPlane
   mitk::PlaneGeometry::Pointer m_Plane;
 
   bool m_UseAllPoints;
 
   //##Documentation
   //## @brief SlicedGeometry3D containing the created planes
   //##
   SlicedGeometry3D::Pointer m_CreatedGeometries;
 
   mitk::BaseGeometry::Pointer m_FrameGeometry;
 
 private:
   std::deque<mitk::PlaneGeometry::Pointer> planes;
   Point3D last;
   VnlVector normal;
   VnlVector right, down;
   VnlVector targetRight;
   Vector3D targetSpacing;
   ScalarType halfWidthInMM, halfHeightInMM;
   mitk::BaseGeometry::BoundsArrayType bounds;
   Point3D origin;
 };
 
 } // namespace mitk
 
 #endif /* MITKPLANESPERPENDICULARTOLINES_H_HEADER_INCLUDED_C10B22CD */
diff --git a/Modules/Ext/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp b/Modules/Ext/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
index 417a7cf365..5b0941bdf6 100644
--- a/Modules/Ext/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
+++ b/Modules/Ext/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
@@ -1,165 +1,165 @@
 /*===================================================================
 
 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 "mitkPointSetToCurvedGeometryFilter.h"
 #include "mitkThinPlateSplineCurvedGeometry.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkImage.h"
 #include "mitkDataNode.h"
 #include "mitkGeometryData.h"
-#include "mitkGeometry2DData.h"
+#include "mitkPlaneGeometryData.h"
 #include "mitkProperties.h"
 #include "itkMesh.h"
 #include "itkPointSet.h"
 
 mitk::PointSetToCurvedGeometryFilter::PointSetToCurvedGeometryFilter()
 {
   m_ProjectionMode = YZPlane;
   m_PCAPlaneCalculator = mitk::PlaneFit::New();
   m_ImageToBeMapped = NULL;
   m_Sigma = 1000;
-  mitk::Geometry2DData::Pointer output = static_cast<mitk::Geometry2DData*> ( this->MakeOutput ( 0 ).GetPointer() );
+  mitk::PlaneGeometryData::Pointer output = static_cast<mitk::PlaneGeometryData*> ( this->MakeOutput ( 0 ).GetPointer() );
   output->Initialize();
   Superclass::SetNumberOfRequiredOutputs ( 1 );
   Superclass::SetNthOutput ( 0, output.GetPointer() );
 }
 
 
 
 mitk::PointSetToCurvedGeometryFilter::~PointSetToCurvedGeometryFilter()
 {}
 
 void mitk::PointSetToCurvedGeometryFilter::GenerateOutputInformation()
 {
   mitk::PointSet::ConstPointer input  = this->GetInput();
-  mitk::Geometry2DData::Pointer output  = dynamic_cast<mitk::Geometry2DData*> ( this->GetOutput() );
+  mitk::PlaneGeometryData::Pointer output  = dynamic_cast<mitk::PlaneGeometryData*> ( this->GetOutput() );
 
   if ( input.IsNull() )
     itkGenericExceptionMacro ( "Input point set is NULL!" );
 
   if ( input->GetTimeGeometry()->CountTimeSteps() != 1 )
     itkWarningMacro ( "More than one time step is not yet supported!" );
 
   if ( output.IsNull() )
     itkGenericExceptionMacro ( "Output is NULL!" );
 
   if ( m_ImageToBeMapped.IsNull() )
     itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
 
   bool update = false;
-  if ( output->GetGeometry() == NULL || output->GetGeometry2D() == NULL || output->GetTimeGeometry() == NULL )
+  if ( output->GetGeometry() == NULL || output->GetPlaneGeometry() == NULL || output->GetTimeGeometry() == NULL )
     update = true;
   if ( ( ! update ) && ( output->GetTimeGeometry()->CountTimeSteps() != input->GetTimeGeometry()->CountTimeSteps() ) )
     update = true;
   if ( update )
   {
     mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
     output->SetGeometry(curvedGeometry);
   }
 }
 
 void mitk::PointSetToCurvedGeometryFilter::GenerateData()
 {
   mitk::PointSet::ConstPointer input  = this->GetInput();
   mitk::GeometryData::Pointer output  = this->GetOutput();
 
   //
   // check preconditions
   //
   if ( input.IsNull() )
     itkGenericExceptionMacro ( "Input point set is NULL!" );
   if ( output.IsNull() )
     itkGenericExceptionMacro ( "output geometry data is NULL!" );
   if ( output->GetTimeGeometry() == NULL )
     itkGenericExceptionMacro ( "Output time sliced geometry is NULL!" );
   if ( output->GetTimeGeometry()->GetGeometryForTimeStep ( 0 ).IsNull() )
     itkGenericExceptionMacro ( "Output geometry3d is NULL!" );
   mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = dynamic_cast<mitk::ThinPlateSplineCurvedGeometry*> ( output->GetTimeGeometry()->GetGeometryForTimeStep( 0 ).GetPointer() );
   if ( curvedGeometry.IsNull() )
     itkGenericExceptionMacro ( "Output geometry3d is not an instance of mitk::ThinPlateSPlineCurvedGeometry!" );
   if ( m_ImageToBeMapped.IsNull() )
     itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
 
   //
   // initialize members if needed
   //
   if ( m_XYPlane.IsNull()  ||  m_XZPlane.IsNull() || m_YZPlane.IsNull() )
   {
     m_ImageToBeMapped->UpdateOutputInformation();
     const mitk::BaseGeometry* imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
     imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
     m_XYPlane = mitk::PlaneGeometry::New();
     m_XZPlane = mitk::PlaneGeometry::New();
     m_YZPlane = mitk::PlaneGeometry::New();
     m_XYPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Axial );
     m_YZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Sagittal );
     m_XZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Frontal );
   }
   if ( m_PlaneLandmarkProjector.IsNull() )
   {
     m_PlaneLandmarkProjector = mitk::PlaneLandmarkProjector::New();
     m_SphereLandmarkProjector = mitk::SphereLandmarkProjector::New();
   }
 
   //
   // set up geometry according to the current settings
   //
   if ( m_ProjectionMode == Sphere )
   {
     curvedGeometry->SetLandmarkProjector ( m_SphereLandmarkProjector );
   }
   else
   {
     if ( m_ProjectionMode == XYPlane )
       m_PlaneLandmarkProjector->SetProjectionPlane ( m_XYPlane );
     else if ( m_ProjectionMode == XZPlane )
       m_PlaneLandmarkProjector->SetProjectionPlane ( m_XZPlane );
     else if ( m_ProjectionMode == YZPlane )
       m_PlaneLandmarkProjector->SetProjectionPlane ( m_YZPlane );
     else if ( m_ProjectionMode == PCAPlane )
     {
       itkExceptionMacro ( "PCAPlane not yet implemented!" );
       m_PCAPlaneCalculator->SetInput ( input );
       m_PCAPlaneCalculator->Update();
       m_PlaneLandmarkProjector->SetProjectionPlane ( dynamic_cast<mitk::PlaneGeometry*> ( m_PCAPlaneCalculator->GetOutput() ) );
     }
     else
       itkExceptionMacro ( "Unknown projection mode" );
 
     curvedGeometry->SetLandmarkProjector ( m_PlaneLandmarkProjector );
   }
   //curvedGeometry->SetReferenceGeometry( m_ImageToBeMapped->GetGeometry() );
   curvedGeometry->SetTargetLandmarks ( input->GetPointSet ( 0 )->GetPoints() );
   curvedGeometry->SetSigma ( m_Sigma );
   curvedGeometry->ComputeGeometry();
   curvedGeometry->SetOversampling ( 1.0 );
 
 }
 
 
 void mitk::PointSetToCurvedGeometryFilter::SetDefaultCurvedGeometryProperties ( mitk::DataNode* node )
 {
   if ( node == NULL )
   {
     itkGenericOutputMacro ( "Warning: node is NULL!" );
     return;
   }
   node->SetIntProperty ( "xresolution", 50 );
   node->SetIntProperty ( "yresolution", 50 );
   node->SetProperty ( "name", mitk::StringProperty::New ( "Curved Plane" ) );
   // exclude extent of this plane when calculating DataStorage bounding box
   node->SetProperty ( "includeInBoundingBox", mitk::BoolProperty::New ( false ) );
 }
diff --git a/Modules/Ext/IO/mitkParRecFileReader.cpp b/Modules/Ext/IO/mitkParRecFileReader.cpp
index c2d98807a4..045064e54d 100644
--- a/Modules/Ext/IO/mitkParRecFileReader.cpp
+++ b/Modules/Ext/IO/mitkParRecFileReader.cpp
@@ -1,292 +1,292 @@
 /*===================================================================
 
 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 "mitkParRecFileReader.h"
 #include <itkImageFileReader.h>
 
 #ifdef __GNUC__
 #define stricmp strcasecmp
 #endif
 
 void mitk::ParRecFileReader::GenerateOutputInformation()
 {
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_ReadHeaderTime.GetMTime()))
     return;
 
   itkDebugMacro(<<"Reading PAR file for GenerateOutputInformation()" << m_FileName);
 
   // Check to see if we can read the file given the name or prefix
   //
   if ( m_FileName == "" && m_FilePrefix == "" )
   {
     throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
   }
 
   m_RecFileName = "";
   if( m_FileName != "")
   {
     int extPos=m_FileName.find_last_of(".");
     if(extPos>=-1)
     {
       const char *ext=m_FileName.c_str()+extPos+1;
       if(stricmp(ext,"par")==0)
         m_RecFileName = m_FileName.substr(0,extPos);
       else
         m_RecFileName = m_FileName;
     }
     else
         m_RecFileName = m_FileName;
 
     m_RecFileName.append(".rec");
 
     bool headerRead = false;
 
     bool signedCharType = true;
     unsigned int dimension=0;
     unsigned int dimensions[4]={0,0,1,1};
     float sliceThickness=0.0;
     float sliceGap=0.0;
     float sliceSpacing=0.0;
     mitk::Vector3D thickness; thickness.Fill(1.0);
     mitk::Vector3D gap; gap.Fill(0.0);
     mitk::Vector3D spacing;
 
     FILE *f;
     f=fopen(m_FileName.c_str(), "r");
     if(f!=NULL)
     {
       while(!feof(f))
       {
         char s[300], *p;
         char* ignored = fgets(s,200,f);
         ++ignored;
         if(strstr(s,"Max. number of cardiac phases"))
         {
           p=strchr(s,':')+1;
           dimensions[3]=atoi(p);
           if(dimensions[3]>1)
             dimension=4;
         }
         else
         if(strstr(s,"Max. number of slices/locations"))
         {
           p=strchr(s,':')+1;
           dimensions[2]=atoi(p);
           if(dimension==0)
           {
             if(dimensions[2]>1)
               dimension=3;
             else
               dimension=2;
           }
         }
         else
         if(strstr(s,"Image pixel size"))
         {
           p=strchr(s,':')+1;
           int bpe=atoi(p);
           if(bpe!=8)
             signedCharType = false;
         }
         else
         if(strstr(s,"Recon resolution"))
         {
           p=s+strcspn(s,"0123456789");
           sscanf(p,"%u %u", dimensions, dimensions+1);
         }
         else
         if(strstr(s,"FOV (ap,fh,rl) [mm]"))
         {
           p=s+strcspn(s,"0123456789");
           char *oldLocale = setlocale(LC_ALL, 0);
           sscanf(p,"%f %f %f", &thickness[0], &thickness[1], &thickness[2]);
           setlocale(LC_ALL, oldLocale);
         }
         else
         if(strstr(s,"Slice thickness [mm]"))
         {
           p=s+strcspn(s,"0123456789");
           char *oldLocale = setlocale(LC_ALL, 0);
           sscanf(p,"%f", &sliceThickness);
           setlocale(LC_ALL, oldLocale);
         }
         else
         if(strstr(s,"Slice gap [mm]"))
         {
           p=s+strcspn(s,"-0123456789");
           char *oldLocale = setlocale(LC_ALL, 0);
           sscanf(p,"%f", &sliceGap);
           setlocale(LC_ALL, oldLocale);
         }
       }
       fclose(f);
 
 //C:\home\ivo\data\coronaries\ucsf-wholeheart-2.par
       sliceSpacing = sliceThickness+sliceGap;
       if((dimension>0) && (dimensions[0]>0) && (dimensions[1]>0) && (sliceThickness>0) && (sliceSpacing>0))
       {
         headerRead = true;
         if(fabs(thickness[0]/dimensions[2]-sliceSpacing)<0.0001)
           thickness[0]=thickness[1];
         else
         if(fabs(thickness[1]/dimensions[2]-sliceSpacing)<0.0001)
           thickness[1]=thickness[0];
         thickness[2]=sliceSpacing;
 
         thickness[0]/=dimensions[0];
         thickness[1]/=dimensions[1];
         spacing=thickness+gap;
       }
     }
 
     if( headerRead == false)
     {
       itk::ImageFileReaderException e(__FILE__, __LINE__);
       std::ostringstream msg;
       msg << " Could not read file "
         << m_FileName.c_str();
       e.SetDescription(msg.str().c_str());
       throw e;
       return;
     }
 
     // define types
     mitk::PixelType SCType = mitk::MakeScalarPixelType<signed char>();
     mitk::PixelType SSType = mitk::MakeScalarPixelType<signed short>();
 
     if( signedCharType )
       output->Initialize(SCType, dimension, dimensions);
     else
       output->Initialize(SSType, dimension, dimensions);
 
     output->GetSlicedGeometry()->SetSpacing(spacing);
 
-    //output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), dimensions).GetPointer(), 0);
+    //output->GetSlicedGeometry()->SetPlaneGeometry(mitk::Image::BuildStandardPlanePlaneGeometry(output->GetSlicedGeometry(), dimensions).GetPointer(), 0);
     output->GetSlicedGeometry()->SetEvenlySpaced();
   }
 
   m_ReadHeaderTime.Modified();
 }
 
 void mitk::ParRecFileReader::GenerateData()
 {
   mitk::Image::Pointer output = this->GetOutput();
 
   // Check to see if we can read the file given the name or prefix
   //
   if ( m_RecFileName == "" )
   {
     throw itk::ImageFileReaderException(__FILE__, __LINE__, "FileName for rec-file empty");
   }
 
   if( m_RecFileName != "")
   {
     FILE *f = fopen(m_RecFileName.c_str(), "r");
     if(f==NULL)
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Could not open rec-file.");
     }
 
     int zstart, zmax;
     int tstart, tmax;
 
     zstart=output->GetRequestedRegion().GetIndex(2);
     tstart=output->GetRequestedRegion().GetIndex(3);
 
     zmax=zstart+output->GetRequestedRegion().GetSize(2);
     tmax=tstart+output->GetRequestedRegion().GetSize(3);
 
     int sliceSize=output->GetDimension(0)*output->GetDimension(1)*output->GetPixelType().GetBpe()/8;
     void *data = malloc(sliceSize);
 
     bool ignore4Dtopogram=false;
     {
       int slicePlusTimeSize=output->GetDimension(0)*output->GetDimension(1)*output->GetDimension(3)*output->GetPixelType().GetBpe()/8;
     if(output->GetDimension(3)>1)
       ignore4Dtopogram=true;
 
       int z,t;
       for(t=tstart;t<tmax;++t)
         for(z=zstart;z<zmax;++z)
         {
           if(ignore4Dtopogram)
             fseek(f,slicePlusTimeSize*z+(sliceSize+1)*t,SEEK_SET);
           else
             fseek(f,slicePlusTimeSize*z+sliceSize*t,SEEK_SET);
           size_t ignored = fread(data, sliceSize, 1, f);
           ++ignored;
           output->SetSlice(data,z,t,0);
         }
     }
     //else
     //{
     //  for(;z<zmax;++z)
     //  {
     //    fseek(f,sliceSize*z,SEEK_SET);
     //    fread(data, sliceSize, 1, f);
     //    output->SetSlice(data,z,0,0);
     //  }
     //}
     free(data);
 
     fclose(f);
   }
 }
 
 bool mitk::ParRecFileReader::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
 {
   // First check the extension
   if(  filename == "" )
     {
       //MITK_INFO<<"No filename specified."<<std::endl;
     return false;
     }
 
   bool extensionFound = false;
   std::string::size_type PARPos = filename.rfind(".par");
   if ((PARPos != std::string::npos)
       && (PARPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   PARPos = filename.rfind(".PAR");
   if ((PARPos != std::string::npos)
       && (PARPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   if( !extensionFound )
     {
       //MITK_INFO<<"The filename extension is not recognized."<<std::endl;
     return false;
     }
 
   return true;
 }
 
 mitk::ParRecFileReader::ParRecFileReader()
 : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
 }
 
 mitk::ParRecFileReader::~ParRecFileReader()
 {
 }
diff --git a/Modules/Ext/Interactions/mitkAffineInteractor3D.cpp b/Modules/Ext/Interactions/mitkAffineInteractor3D.cpp
index 70aa724730..0c0f25130e 100644
--- a/Modules/Ext/Interactions/mitkAffineInteractor3D.cpp
+++ b/Modules/Ext/Interactions/mitkAffineInteractor3D.cpp
@@ -1,489 +1,489 @@
 /*===================================================================
 
 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 "mitkAffineInteractor3D.h"
 #include "mitkPointOperation.h"
 #include "mitkPositionEvent.h"
 #include "mitkStatusBar.h"
 #include "mitkDataNode.h"
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 #include "mitkStateEvent.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkStateMachineFactory.h"
 #include "mitkStateTransitionOperation.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkRotationOperation.h"
 
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkInteractorStyle.h>
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 #include <vtkPoints.h>
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 
 
 namespace mitk
 {
 
 //how precise must the user pick the point
 //default value
 AffineInteractor3D
 ::AffineInteractor3D(const char * type, DataNode* dataNode, int /* n */ )
 : Interactor( type, dataNode ),
   m_Precision( 6.5 ),
   m_InteractionMode( INTERACTION_MODE_TRANSLATION )
 {
   Geometry3D::Pointer geo3D = Geometry3D::New();
   m_OriginalGeometry = dynamic_cast<BaseGeometry*>(geo3D.GetPointer());
 
   // Initialize vector arithmetic
   m_ObjectNormal[0] = 0.0;
   m_ObjectNormal[1] = 0.0;
   m_ObjectNormal[2] = 1.0;
 }
 
 
 AffineInteractor3D::~AffineInteractor3D()
 {
 }
 
 
 void AffineInteractor3D::SetInteractionMode( unsigned int interactionMode )
 {
   m_InteractionMode = interactionMode;
 }
 
 
 void AffineInteractor3D::SetInteractionModeToTranslation()
 {
   m_InteractionMode = INTERACTION_MODE_TRANSLATION;
 }
 
 
 void AffineInteractor3D::SetInteractionModeToRotation()
 {
   m_InteractionMode = INTERACTION_MODE_ROTATION;
 }
 
 
 unsigned int AffineInteractor3D::GetInteractionMode() const
 {
   return m_InteractionMode;
 }
 
 
 void AffineInteractor3D::SetPrecision( ScalarType precision )
 {
   m_Precision = precision;
 }
 
 // Overwritten since this class can handle it better!
 float AffineInteractor3D
 ::CanHandleEvent(StateEvent const* stateEvent) const
 {
   float returnValue = 0.5;
 
 
   // If it is a key event that can be handled in the current state,
   // then return 0.5
   DisplayPositionEvent const *disPosEvent =
     dynamic_cast <const DisplayPositionEvent *> (stateEvent->GetEvent());
 
   // Key event handling:
   if (disPosEvent == NULL)
   {
     // Check if the current state has a transition waiting for that key event.
     if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       return 0.5;
     }
     else
     {
       return 0.0;
     }
   }
 
   //on MouseMove do nothing!
   //if (stateEvent->GetEvent()->GetType() == Type_MouseMove)
   //{
   //  return 0.0;
   //}
 
   //if the event can be understood and if there is a transition waiting for that event
   if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
   {
     returnValue = 0.5;//it can be understood
   }
 
   //int timeStep = disPosEvent->GetSender()->GetTimeStep();
 
   //CurveModel *curveModel = dynamic_cast<CurveModel *>(
   //  m_DataNode->GetData() );
 
   //if ( curveModel != NULL )
   //{
   //  // Get the PlaneGeometry of the window the user interacts with (for 2D point
   //  // projection)
   //  BaseRenderer *renderer = stateEvent->GetEvent()->GetSender();
-  //  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldGeometry2D();
+  //  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
 
   //  // For reading on the points, Ids etc
   //  //CurveModel::PointSetType *pointSet = curveModel->GetPointSet( timeStep );
   //  //if ( pointSet == NULL )
   //  //{
   //  //  return 0.0;
   //  //}
 
   //}
   return returnValue;
 }
 
 
 bool AffineInteractor3D
 ::ExecuteAction( Action *action, StateEvent const *stateEvent )
 {
   bool ok = false;
 
   // Get data object
   BaseData *data = m_DataNode->GetData();
   if ( data == NULL )
   {
     MITK_ERROR << "No data object present!";
     return ok;
   }
 
   // Get Event and extract renderer
   const Event *event = stateEvent->GetEvent();
   BaseRenderer *renderer = NULL;
   vtkRenderWindow *renderWindow = NULL;
   vtkRenderWindowInteractor *renderWindowInteractor = NULL;
   vtkRenderer *currentVtkRenderer = NULL;
   vtkCamera *camera = NULL;
 
   if ( event != NULL )
   {
     renderer = event->GetSender();
     if ( renderer != NULL )
     {
       renderWindow = renderer->GetRenderWindow();
       if ( renderWindow != NULL )
       {
         renderWindowInteractor = renderWindow->GetInteractor();
         if ( renderWindowInteractor != NULL )
         {
           currentVtkRenderer = renderWindowInteractor
             ->GetInteractorStyle()->GetCurrentRenderer();
           if ( currentVtkRenderer != NULL )
           {
             camera = currentVtkRenderer->GetActiveCamera();
           }
         }
       }
     }
   }
 
   // Check if we have a DisplayPositionEvent
   const DisplayPositionEvent *dpe =
     dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
   if ( dpe != NULL )
   {
     m_CurrentPickedPoint = dpe->GetWorldPosition();
     m_CurrentPickedDisplayPoint = dpe->GetDisplayPosition();
   }
 
   // Get the timestep to also support 3D+t
   int timeStep = 0;
   ScalarType timeInMS = 0.0;
   if ( renderer != NULL )
   {
     timeStep = renderer->GetTimeStep( data );
     timeInMS = renderer->GetTime();
   }
 
   // If data is an mitk::Surface, extract it
   Surface *surface = dynamic_cast< Surface * >( data );
   vtkPolyData *polyData = NULL;
   if ( surface != NULL )
   {
     polyData = surface->GetVtkPolyData( timeStep );
 
     // Extract surface normal from surface (if existent, otherwise use default)
     vtkPointData *pointData = polyData->GetPointData();
     if ( pointData != NULL )
     {
       vtkDataArray *normal = polyData->GetPointData()->GetVectors( "planeNormal" );
       if ( normal != NULL )
       {
         m_ObjectNormal[0] = normal->GetComponent( 0, 0 );
         m_ObjectNormal[1] = normal->GetComponent( 0, 1 );
         m_ObjectNormal[2] = normal->GetComponent( 0, 2 );
       }
     }
   }
 
   // Get geometry object
   m_Geometry = data->GetGeometry( timeStep );
 
 
   // Make sure that the data (if time-resolved) has enough entries;
   // if not, create the required extra ones (empty)
   data->Expand( timeStep+1 );
 
 
   switch (action->GetActionId())
   {
   case AcDONOTHING:
     ok = true;
     break;
 
 
   case AcCHECKOBJECT:
     {
       // Re-enable VTK interactor (may have been disabled previously)
       if ( renderWindowInteractor != NULL )
       {
         renderWindowInteractor->Enable();
       }
 
       // Check if we have a DisplayPositionEvent
       const DisplayPositionEvent *dpe =
         dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
       if ( dpe == NULL )
       {
         ok = true;
         break;
       }
 
       // Check if an object is present at the current mouse position
       DataNode *pickedNode = dpe->GetPickedObjectNode();
       StateEvent *newStateEvent;
       if ( pickedNode == m_DataNode )
       {
         // Yes: object will be selected
         newStateEvent = new StateEvent( EIDYES );
       }
       else
       {
         // No: back to start state
         newStateEvent = new StateEvent( EIDNO );
       }
 
       this->HandleEvent( newStateEvent );
 
       ok = true;
       break;
     }
 
   case AcDESELECTOBJECT:
     {
       // Color object white
       m_DataNode->SetColor( 1.0, 1.0, 1.0 );
       RenderingManager::GetInstance()->RequestUpdateAll();
 
       // Colorize surface / wireframe as inactive
       this->ColorizeSurface( polyData,
         m_CurrentPickedPoint, -1.0 );
 
       ok = true;
       break;
     }
 
   case AcSELECTPICKEDOBJECT:
     {
       // Color object red
       m_DataNode->SetColor( 1.0, 0.0, 0.0 );
       RenderingManager::GetInstance()->RequestUpdateAll();
 
       // Colorize surface / wireframe dependend on distance from picked point
       this->ColorizeSurface( polyData,
         m_CurrentPickedPoint, 0.0 );
 
       ok = true;
       break;
     }
 
   case AcINITMOVE:
     {
       // Disable VTK interactor until MITK interaction has been completed
       if ( renderWindowInteractor != NULL )
       {
         renderWindowInteractor->Disable();
       }
 
       // Check if we have a DisplayPositionEvent
       const DisplayPositionEvent *dpe =
         dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
       if ( dpe == NULL )
       {
         ok = true;
         break;
       }
 
       //DataNode *pickedNode = dpe->GetPickedObjectNode();
 
       m_InitialPickedPoint = m_CurrentPickedPoint;
       m_InitialPickedDisplayPoint = m_CurrentPickedDisplayPoint;
 
       if ( currentVtkRenderer != NULL )
       {
         vtkInteractorObserver::ComputeDisplayToWorld(
           currentVtkRenderer,
           m_InitialPickedDisplayPoint[0],
           m_InitialPickedDisplayPoint[1],
           0.0, //m_InitialInteractionPickedPoint[2],
           m_InitialPickedPointWorld );
       }
 
 
       // Make deep copy of current Geometry3D of the plane
       data->UpdateOutputInformation(); // make sure that the Geometry is up-to-date
       m_OriginalGeometry = static_cast< BaseGeometry * >(
         data->GetGeometry( timeStep )->Clone().GetPointer() );
 
       ok = true;
       break;
     }
 
   case AcMOVE:
     {
       // Check if we have a DisplayPositionEvent
       const DisplayPositionEvent *dpe =
         dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
       if ( dpe == NULL )
       {
         ok = true;
         break;
       }
 
       if ( currentVtkRenderer != NULL )
       {
         vtkInteractorObserver::ComputeDisplayToWorld(
           currentVtkRenderer,
           m_CurrentPickedDisplayPoint[0],
           m_CurrentPickedDisplayPoint[1],
           0.0, //m_InitialInteractionPickedPoint[2],
           m_CurrentPickedPointWorld );
       }
 
 
       Vector3D interactionMove;
       interactionMove[0] = m_CurrentPickedPointWorld[0] - m_InitialPickedPointWorld[0];
       interactionMove[1] = m_CurrentPickedPointWorld[1] - m_InitialPickedPointWorld[1];
       interactionMove[2] = m_CurrentPickedPointWorld[2] - m_InitialPickedPointWorld[2];
 
       if ( m_InteractionMode == INTERACTION_MODE_TRANSLATION )
       {
         Point3D origin = m_OriginalGeometry->GetOrigin();
 
         Vector3D transformedObjectNormal;
         data->GetGeometry( timeStep )->IndexToWorld(
           m_ObjectNormal, transformedObjectNormal );
 
         data->GetGeometry( timeStep )->SetOrigin(
           origin + transformedObjectNormal * (interactionMove * transformedObjectNormal) );
       }
       else if ( m_InteractionMode == INTERACTION_MODE_ROTATION )
       {
         if ( camera )
         {
           double vpn[3];
           camera->GetViewPlaneNormal( vpn );
 
           Vector3D viewPlaneNormal;
           viewPlaneNormal[0] = vpn[0];
           viewPlaneNormal[1] = vpn[1];
           viewPlaneNormal[2] = vpn[2];
 
           Vector3D rotationAxis =
             itk::CrossProduct( viewPlaneNormal, interactionMove );
           rotationAxis.Normalize();
 
           int *size = currentVtkRenderer->GetSize();
           double l2 =
             (m_CurrentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) *
             (m_CurrentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) +
             (m_CurrentPickedDisplayPoint[1] - m_InitialPickedDisplayPoint[1]) *
             (m_CurrentPickedDisplayPoint[1] - m_InitialPickedDisplayPoint[1]);
 
           double rotationAngle = 360.0 * sqrt(l2/(size[0]*size[0]+size[1]*size[1]));
 
           // Use center of data bounding box as center of rotation
           Point3D rotationCenter = m_OriginalGeometry->GetCenter();;
 
           // Reset current Geometry3D to original state (pre-interaction) and
           // apply rotation
           RotationOperation op( OpROTATE, rotationCenter, rotationAxis, rotationAngle );
           BaseGeometry::Pointer newGeometry = static_cast< BaseGeometry * >(
             m_OriginalGeometry->Clone().GetPointer() );
           newGeometry->ExecuteOperation( &op );
           data->SetClonedGeometry(newGeometry, timeStep);
         }
       }
 
       RenderingManager::GetInstance()->RequestUpdateAll();
       ok = true;
       break;
     }
 
 
 
   default:
     return Superclass::ExecuteAction( action, stateEvent );
   }
 
   return ok;
 }
 
 bool AffineInteractor3D::ColorizeSurface( vtkPolyData *polyData,
   const Point3D & /*pickedPoint*/, double scalar )
 {
   if ( polyData == NULL )
   {
     return false;
   }
 
   //vtkPoints *points = polyData->GetPoints();
   vtkPointData *pointData = polyData->GetPointData();
   if ( pointData == NULL )
   {
     return false;
   }
 
   vtkDataArray *scalars = pointData->GetScalars();
   if ( scalars == NULL )
   {
     return false;
   }
 
   for ( unsigned int i = 0; i < pointData->GetNumberOfTuples(); ++i )
   {
     scalars->SetComponent( i, 0, scalar );
   }
 
   polyData->Modified();
   pointData->Update();
 
   return true;
 }
 
 
 } // namespace
diff --git a/Modules/Ext/Interactions/mitkSurfaceDeformationInteractor3D.cpp b/Modules/Ext/Interactions/mitkSurfaceDeformationInteractor3D.cpp
index 0089494a96..f385279407 100644
--- a/Modules/Ext/Interactions/mitkSurfaceDeformationInteractor3D.cpp
+++ b/Modules/Ext/Interactions/mitkSurfaceDeformationInteractor3D.cpp
@@ -1,498 +1,498 @@
 /*===================================================================
 
 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 "mitkSurfaceDeformationInteractor3D.h"
 #include "mitkPointOperation.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkWheelEvent.h"
 #include "mitkStatusBar.h"
 #include "mitkDataNode.h"
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 #include "mitkStateEvent.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkStateMachineFactory.h"
 #include "mitkStateTransitionOperation.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkSurface.h"
 
 
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkInteractorStyle.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 
 
 //how precise must the user pick the point
 //default value
 mitk::SurfaceDeformationInteractor3D
 ::SurfaceDeformationInteractor3D(const char * type, DataNode* dataNode, int /* n */ )
 : Interactor( type, dataNode ),
   m_Precision( 6.5 ),
   m_PickedSurfaceNode( NULL ),
   m_PickedSurface( NULL ),
   m_GaussSigma( 30.0 )
 {
   m_OriginalPolyData = vtkPolyData::New();
 
   // Initialize vector arithmetic
   m_ObjectNormal[0] = 0.0;
   m_ObjectNormal[1] = 0.0;
   m_ObjectNormal[2] = 1.0;
 }
 
 mitk::SurfaceDeformationInteractor3D::~SurfaceDeformationInteractor3D()
 {
   m_OriginalPolyData->Delete();
 }
 
 void mitk::SurfaceDeformationInteractor3D::SetPrecision( mitk::ScalarType precision )
 {
   m_Precision = precision;
 }
 
 // Overwritten since this class can handle it better!
 float mitk::SurfaceDeformationInteractor3D
 ::CanHandleEvent(StateEvent const* stateEvent) const
 {
   float returnValue = 0.5;
 
 
   // If it is a key event that can be handled in the current state,
   // then return 0.5
   mitk::DisplayPositionEvent const *disPosEvent =
     dynamic_cast <const mitk::DisplayPositionEvent *> (stateEvent->GetEvent());
 
   // Key event handling:
   if (disPosEvent == NULL)
   {
     // Check if the current state has a transition waiting for that key event.
     if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       return 0.5;
     }
     else
     {
       return 0.0;
     }
   }
 
   //on MouseMove do nothing!
   //if (stateEvent->GetEvent()->GetType() == mitk::Type_MouseMove)
   //{
   //  return 0.0;
   //}
 
   //if the event can be understood and if there is a transition waiting for that event
   if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
   {
     returnValue = 0.5;//it can be understood
   }
 
   //int timeStep = disPosEvent->GetSender()->GetTimeStep();
 
   //mitk::CurveModel *curveModel = dynamic_cast<mitk::CurveModel *>(
   //  m_DataNode->GetData() );
 
   //if ( curveModel != NULL )
   //{
   //  // Get the PlaneGeometry of the window the user interacts with (for 2D point
   //  // projection)
   //  mitk::BaseRenderer *renderer = stateEvent->GetEvent()->GetSender();
-  //  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldGeometry2D();
+  //  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
 
   //  // For reading on the points, Ids etc
   //  //mitk::CurveModel::PointSetType *pointSet = curveModel->GetPointSet( timeStep );
   //  //if ( pointSet == NULL )
   //  //{
   //  //  return 0.0;
   //  //}
 
   //}
   return returnValue;
 }
 
 
 bool mitk::SurfaceDeformationInteractor3D
 ::ExecuteAction( Action *action, mitk::StateEvent const *stateEvent )
 {
   bool ok = false;
 
   // Get data object
   mitk::BaseData *data = m_DataNode->GetData();
   if ( data == NULL )
   {
     MITK_ERROR << "No data object present!";
     return ok;
   }
 
   // Get mitk::Event and extract renderer
   const mitk::Event *event = stateEvent->GetEvent();
   mitk::BaseRenderer *renderer = NULL;
   vtkRenderWindow *renderWindow = NULL;
   vtkRenderWindowInteractor *renderWindowInteractor = NULL;
 
   if ( event != NULL )
   {
     renderer = event->GetSender();
     if ( renderer != NULL )
     {
       renderWindow = renderer->GetRenderWindow();
       if ( renderWindow != NULL )
       {
         renderWindowInteractor = renderWindow->GetInteractor();
       }
     }
   }
 
   // Check if we have a DisplayPositionEvent
   const mitk::DisplayPositionEvent *dpe =
     dynamic_cast< const mitk::DisplayPositionEvent * >( stateEvent->GetEvent() );
   if ( dpe != NULL )
   {
     m_PickedSurfaceNode = dpe->GetPickedObjectNode();
     m_CurrentPickedPoint = dpe->GetWorldPosition();
     m_CurrentPickedDisplayPoint = dpe->GetDisplayPosition();
   }
 
 
   // Get the timestep to also support 3D+t
   int timeStep = 0;
   mitk::ScalarType timeInMS = 0.0;
   if ( renderer != NULL )
   {
     timeStep = renderer->GetTimeStep( data );
     timeInMS = renderer->GetTime();
   }
 
   // Extract surface
   m_Surface = dynamic_cast< Surface * >( data );
   if ( m_Surface != NULL )
   {
     m_PolyData = m_Surface->GetVtkPolyData( timeStep );
   }
   else
   {
     m_PolyData = NULL;
   }
 
   // Extract surface normal from surface (if existent, otherwise use default)
   vtkPointData *pointData = m_PolyData->GetPointData();
   if ( pointData != NULL )
   {
     vtkDataArray *normal = m_PolyData->GetPointData()->GetVectors( "planeNormal" );
     if ( normal != NULL )
     {
       m_ObjectNormal[0] = normal->GetComponent( 0, 0 );
       m_ObjectNormal[1] = normal->GetComponent( 0, 1 );
       m_ObjectNormal[2] = normal->GetComponent( 0, 2 );
     }
   }
 
   // Get geometry object
   m_Geometry = data->GetGeometry( timeStep );
 
 
   // Make sure that the data (if time-resolved) has enough entries;
   // if not, create the required extra ones (empty)
   data->Expand( timeStep+1 );
 
 
   switch (action->GetActionId())
   {
   case AcDONOTHING:
     ok = true;
     break;
 
 
   case AcCHECKOBJECT:
     {
       // Check if an object is present at the current mouse position
       m_PickedSurface = NULL;
       m_PickedPolyData = NULL;
 
       if ( m_PickedSurfaceNode != NULL )
       {
         m_PickedSurface = dynamic_cast< mitk::Surface * >( m_PickedSurfaceNode->GetData() );
         if ( m_PickedSurface != NULL )
         {
           m_PickedPolyData = m_PickedSurface->GetVtkPolyData( timeStep );
         }
       }
 
       mitk::StateEvent *newStateEvent;
       if ( (m_PickedSurfaceNode == m_DataNode) && (m_PickedSurface != NULL) )
       {
         // Yes: object will be selected
         newStateEvent = new mitk::StateEvent( EIDYES );
 
         // Disable VTK interactor until MITK interaction has been completed
         if ( renderWindowInteractor != NULL )
         {
           renderWindowInteractor->Disable();
         }
       }
       else
       {
         // No: back to start state
         newStateEvent = new mitk::StateEvent( EIDNO );
 
         // Re-enable VTK interactor (may have been disabled previously)
         if ( renderWindowInteractor != NULL )
         {
           renderWindowInteractor->Enable();
         }
       }
 
       this->HandleEvent( newStateEvent );
 
       // Colorized surface at current picked position
       m_SurfaceColorizationCenter = m_CurrentPickedPoint;
 
       ok = true;
       break;
     }
 
   case AcDESELECTOBJECT:
     {
       // Color object white
       m_DataNode->SetColor( 1.0, 1.0, 1.0 );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
       // Colorize surface / wireframe as inactive
       this->ColorizeSurface( m_PolyData,
         m_SurfaceColorizationCenter, COLORIZATION_CONSTANT, -1.0 );
 
       ok = true;
       break;
     }
 
   case AcSELECTPICKEDOBJECT:
     {
       // Color object red
       m_DataNode->SetColor( 1.0, 0.0, 0.0 );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
       // Colorize surface / wireframe dependend on distance from picked point
       this->ColorizeSurface( m_PolyData,
         m_SurfaceColorizationCenter, COLORIZATION_GAUSS );
 
       ok = true;
       break;
     }
 
   case AcINITMOVE:
     {
       // Store current picked point
       m_InitialPickedPoint = m_CurrentPickedPoint;
       m_InitialPickedDisplayPoint = m_CurrentPickedDisplayPoint;
 
       if ( renderWindowInteractor != NULL )
       {
         vtkInteractorObserver::ComputeDisplayToWorld(
           renderWindowInteractor->GetInteractorStyle()->GetCurrentRenderer(),
           m_InitialPickedDisplayPoint[0],
           m_InitialPickedDisplayPoint[1],
           0.0, //m_InitialInteractionPickedPoint[2],
           m_InitialPickedPointWorld );
       }
 
 
       // Make deep copy of vtkPolyData interacted on
       m_OriginalPolyData->DeepCopy( m_PolyData );
 
       ok = true;
       break;
     }
 
   case AcMOVE:
     {
       if ( renderWindowInteractor != NULL )
       {
         vtkInteractorObserver::ComputeDisplayToWorld(
           renderWindowInteractor->GetInteractorStyle()->GetCurrentRenderer(),
           m_CurrentPickedDisplayPoint[0],
           m_CurrentPickedDisplayPoint[1],
           0.0, //m_InitialInteractionPickedPoint[2],
           m_CurrentPickedPointWorld );
       }
 
 
       // Calculate mouse move in 3D space
       mitk::Vector3D interactionMove;
       interactionMove[0] = m_CurrentPickedPointWorld[0] - m_InitialPickedPointWorld[0];
       interactionMove[1] = m_CurrentPickedPointWorld[1] - m_InitialPickedPointWorld[1];
       interactionMove[2] = m_CurrentPickedPointWorld[2] - m_InitialPickedPointWorld[2];
 
       // Transform mouse move into geometry space
       data->UpdateOutputInformation(); // make sure that the Geometry is up-to-date
       mitk::Point3D origin; origin.Fill( 0.0 );
       mitk::Vector3D interactionMoveIndex;
       m_Geometry->WorldToIndex( interactionMove, interactionMoveIndex );
 
 
       // Get picked point and transform into local coordinates
       mitk::Point3D pickedPoint;
       m_Geometry->WorldToIndex( m_InitialPickedPoint, pickedPoint );
       mitk::Vector3D v1 = pickedPoint.GetVectorFromOrigin();
 
       mitk::Vector3D v2 = m_ObjectNormal * (interactionMoveIndex * m_ObjectNormal);
 
 
       vtkPoints *originalPoints = m_OriginalPolyData->GetPoints();
       vtkPoints *deformedPoints = m_PolyData->GetPoints();
 
       double denom = m_GaussSigma * m_GaussSigma * 2;
       double point[3];
       for ( unsigned int i = 0; i < deformedPoints->GetNumberOfPoints(); ++i )
       {
         // Get original point
         double *originalPoint = originalPoints->GetPoint( i );
         mitk::Vector3D v0;
         v0[0] = originalPoint[0];
         v0[1] = originalPoint[1];
         v0[2] = originalPoint[2];
 
 
         // Calculate distance of this point from line through picked point
         double d = itk::CrossProduct( m_ObjectNormal, (v1 - v0) ).GetNorm();
 
         mitk::Vector3D t = v2 * exp( - d * d / denom );
 
         point[0] = originalPoint[0] + t[0];
         point[1] = originalPoint[1] + t[1];
         point[2] = originalPoint[2] + t[2];
         deformedPoints->SetPoint( i, point );
       }
 
       // Make sure that surface is colorized at initial picked position
       // as long as we are in deformation state
       m_SurfaceColorizationCenter = m_InitialPickedPoint;
 
       m_PolyData->Modified();
       m_Surface->Modified();
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       ok = false;
       break;
     }
 
   case AcMODIFY:
     {
       // Check if we have an mitk::WheelEvent
       const mitk::WheelEvent *we =
         dynamic_cast< const mitk::WheelEvent * >( stateEvent->GetEvent() );
       if ( we == NULL )
       {
         ok = true;
         break;
       }
 
       m_GaussSigma += (double) (we->GetDelta()) / 20;;
       if ( m_GaussSigma < 10.0 )
       {
         m_GaussSigma = 10.0;
       }
       else if ( m_GaussSigma > 128.0 )
       {
         m_GaussSigma = 128.0;
       }
 
       // Colorize surface / wireframe dependend on sigma and distance from picked point
       this->ColorizeSurface( m_PolyData,
         m_SurfaceColorizationCenter, COLORIZATION_GAUSS );
 
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll(
         mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS );
       ok = true;
       break;
     }
 
 
   default:
     return Superclass::ExecuteAction( action, stateEvent );
   }
 
   return ok;
 }
 
 
 bool mitk::SurfaceDeformationInteractor3D::ColorizeSurface( vtkPolyData *polyData,
   const Point3D &pickedPoint, int mode, double scalar )
 {
   if ( polyData == NULL )
   {
     return false;
   }
 
   vtkPoints *points = polyData->GetPoints();
   vtkPointData *pointData = polyData->GetPointData();
   if ( pointData == NULL )
   {
     return false;
   }
 
   vtkDataArray *scalars = pointData->GetScalars();
   if ( scalars == NULL )
   {
     return false;
   }
 
   if ( mode == COLORIZATION_GAUSS )
   {
     // Get picked point and transform into local coordinates
     mitk::Point3D localPickedPoint;
     m_Geometry->WorldToIndex( pickedPoint, localPickedPoint );
     mitk::Vector3D v1 = localPickedPoint.GetVectorFromOrigin();
 
     double denom = m_GaussSigma * m_GaussSigma * 2;
     for ( unsigned int i = 0; i < points->GetNumberOfPoints(); ++i )
     {
       // Get original point
       double *point = points->GetPoint( i );
       mitk::Vector3D v0;
       v0[0] = point[0];
       v0[1] = point[1];
       v0[2] = point[2];
 
       // Calculate distance of this point from line through picked point
       double d = itk::CrossProduct( m_ObjectNormal, (v1 - v0) ).GetNorm();
       double t = exp( - d * d / denom );
 
       scalars->SetComponent( i, 0, t );
     }
   }
   else if ( mode == COLORIZATION_CONSTANT )
   {
     for ( unsigned int i = 0; i < pointData->GetNumberOfTuples(); ++i )
     {
       scalars->SetComponent( i, 0, scalar );
     }
   }
 
   polyData->Modified();
   pointData->Update();
 
   return true;
 }
diff --git a/Modules/IOExt/Internal/mitkParRecFileReader.cpp b/Modules/IOExt/Internal/mitkParRecFileReader.cpp
index 7b387b0cca..efcec5aeba 100644
--- a/Modules/IOExt/Internal/mitkParRecFileReader.cpp
+++ b/Modules/IOExt/Internal/mitkParRecFileReader.cpp
@@ -1,292 +1,292 @@
 /*===================================================================
 
 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 "mitkParRecFileReader.h"
 #include <itkImageFileReader.h>
 
 #ifdef __GNUC__
 #define stricmp strcasecmp
 #endif
 
 void mitk::ParRecFileReader::GenerateOutputInformation()
 {
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_ReadHeaderTime.GetMTime()))
     return;
 
   itkDebugMacro(<<"Reading PAR file for GenerateOutputInformation()" << m_FileName);
 
   // Check to see if we can read the file given the name or prefix
   //
   if ( m_FileName == "" && m_FilePrefix == "" )
   {
     throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
   }
 
   m_RecFileName = "";
   if( m_FileName != "")
   {
     int extPos=m_FileName.find_last_of(".");
     if(extPos>=-1)
     {
       const char *ext=m_FileName.c_str()+extPos+1;
       if(stricmp(ext,"par")==0)
         m_RecFileName = m_FileName.substr(0,extPos);
       else
         m_RecFileName = m_FileName;
     }
     else
         m_RecFileName = m_FileName;
 
     m_RecFileName.append(".rec");
 
     bool headerRead = false;
 
     bool signedCharType = true;
     unsigned int dimension=0;
     unsigned int dimensions[4]={0,0,1,1};
     float sliceThickness=0.0;
     float sliceGap=0.0;
     float sliceSpacing=0.0;
     mitk::Vector3D thickness; thickness.Fill(1.0);
     mitk::Vector3D gap; gap.Fill(0.0);
     mitk::Vector3D spacing;
 
     FILE *f;
     f=fopen(m_FileName.c_str(), "r");
     if(f!=NULL)
     {
       while(!feof(f))
       {
         char s[300], *p;
         char* ignored = fgets(s,200,f);
         ++ignored;
         if(strstr(s,"Max. number of cardiac phases"))
         {
           p=strchr(s,':')+1;
           dimensions[3]=atoi(p);
           if(dimensions[3]>1)
             dimension=4;
         }
         else
         if(strstr(s,"Max. number of slices/locations"))
         {
           p=strchr(s,':')+1;
           dimensions[2]=atoi(p);
           if(dimension==0)
           {
             if(dimensions[2]>1)
               dimension=3;
             else
               dimension=2;
           }
         }
         else
         if(strstr(s,"Image pixel size"))
         {
           p=strchr(s,':')+1;
           int bpe=atoi(p);
           if(bpe!=8)
             signedCharType = false;
         }
         else
         if(strstr(s,"Recon resolution"))
         {
           p=s+strcspn(s,"0123456789");
           sscanf(p,"%u %u", dimensions, dimensions+1);
         }
         else
         if(strstr(s,"FOV (ap,fh,rl) [mm]"))
         {
           p=s+strcspn(s,"0123456789");
           char *oldLocale = setlocale(LC_ALL, 0);
           sscanf(p,"%lf %lf %lf", &thickness[0], &thickness[1], &thickness[2]);
           setlocale(LC_ALL, oldLocale);
         }
         else
         if(strstr(s,"Slice thickness [mm]"))
         {
           p=s+strcspn(s,"0123456789");
           char *oldLocale = setlocale(LC_ALL, 0);
           sscanf(p,"%f", &sliceThickness);
           setlocale(LC_ALL, oldLocale);
         }
         else
         if(strstr(s,"Slice gap [mm]"))
         {
           p=s+strcspn(s,"-0123456789");
           char *oldLocale = setlocale(LC_ALL, 0);
           sscanf(p,"%f", &sliceGap);
           setlocale(LC_ALL, oldLocale);
         }
       }
       fclose(f);
 
 //C:\home\ivo\data\coronaries\ucsf-wholeheart-2.par
       sliceSpacing = sliceThickness+sliceGap;
       if((dimension>0) && (dimensions[0]>0) && (dimensions[1]>0) && (sliceThickness>0) && (sliceSpacing>0))
       {
         headerRead = true;
         if(fabs(thickness[0]/dimensions[2]-sliceSpacing)<0.0001)
           thickness[0]=thickness[1];
         else
         if(fabs(thickness[1]/dimensions[2]-sliceSpacing)<0.0001)
           thickness[1]=thickness[0];
         thickness[2]=sliceSpacing;
 
         thickness[0]/=dimensions[0];
         thickness[1]/=dimensions[1];
         spacing=thickness+gap;
       }
     }
 
     if( headerRead == false)
     {
       itk::ImageFileReaderException e(__FILE__, __LINE__);
       std::ostringstream msg;
       msg << " Could not read file "
         << m_FileName.c_str();
       e.SetDescription(msg.str().c_str());
       throw e;
       return;
     }
 
     // define types
     mitk::PixelType SCType = mitk::MakeScalarPixelType<signed char>();
     mitk::PixelType SSType = mitk::MakeScalarPixelType<signed short>();
 
     if( signedCharType )
       output->Initialize(SCType, dimension, dimensions);
     else
       output->Initialize(SSType, dimension, dimensions);
 
     output->GetSlicedGeometry()->SetSpacing(spacing);
 
-    //output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), dimensions).GetPointer(), 0);
+    //output->GetSlicedGeometry()->SetPlaneGeometry(mitk::Image::BuildStandardPlanePlaneGeometry(output->GetSlicedGeometry(), dimensions).GetPointer(), 0);
     output->GetSlicedGeometry()->SetEvenlySpaced();
   }
 
   m_ReadHeaderTime.Modified();
 }
 
 void mitk::ParRecFileReader::GenerateData()
 {
   mitk::Image::Pointer output = this->GetOutput();
 
   // Check to see if we can read the file given the name or prefix
   //
   if ( m_RecFileName == "" )
   {
     throw itk::ImageFileReaderException(__FILE__, __LINE__, "FileName for rec-file empty");
   }
 
   if( m_RecFileName != "")
   {
     FILE *f = fopen(m_RecFileName.c_str(), "r");
     if(f==NULL)
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Could not open rec-file.");
     }
 
     int zstart, zmax;
     int tstart, tmax;
 
     zstart=output->GetRequestedRegion().GetIndex(2);
     tstart=output->GetRequestedRegion().GetIndex(3);
 
     zmax=zstart+output->GetRequestedRegion().GetSize(2);
     tmax=tstart+output->GetRequestedRegion().GetSize(3);
 
     int sliceSize=output->GetDimension(0)*output->GetDimension(1)*output->GetPixelType().GetBpe()/8;
     void *data = malloc(sliceSize);
 
     bool ignore4Dtopogram=false;
     {
       int slicePlusTimeSize=output->GetDimension(0)*output->GetDimension(1)*output->GetDimension(3)*output->GetPixelType().GetBpe()/8;
     if(output->GetDimension(3)>1)
       ignore4Dtopogram=true;
 
       int z,t;
       for(t=tstart;t<tmax;++t)
         for(z=zstart;z<zmax;++z)
         {
           if(ignore4Dtopogram)
             fseek(f,slicePlusTimeSize*z+(sliceSize+1)*t,SEEK_SET);
           else
             fseek(f,slicePlusTimeSize*z+sliceSize*t,SEEK_SET);
           size_t ignored = fread(data, sliceSize, 1, f);
           ++ignored;
           output->SetSlice(data,z,t,0);
         }
     }
     //else
     //{
     //  for(;z<zmax;++z)
     //  {
     //    fseek(f,sliceSize*z,SEEK_SET);
     //    fread(data, sliceSize, 1, f);
     //    output->SetSlice(data,z,0,0);
     //  }
     //}
     free(data);
 
     fclose(f);
   }
 }
 
 bool mitk::ParRecFileReader::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
 {
   // First check the extension
   if(  filename == "" )
     {
       //MITK_INFO<<"No filename specified."<<std::endl;
     return false;
     }
 
   bool extensionFound = false;
   std::string::size_type PARPos = filename.rfind(".par");
   if ((PARPos != std::string::npos)
       && (PARPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   PARPos = filename.rfind(".PAR");
   if ((PARPos != std::string::npos)
       && (PARPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   if( !extensionFound )
     {
       //MITK_INFO<<"The filename extension is not recognized."<<std::endl;
     return false;
     }
 
   return true;
 }
 
 mitk::ParRecFileReader::ParRecFileReader()
 : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
 }
 
 mitk::ParRecFileReader::~ParRecFileReader()
 {
 }
diff --git a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
index 78331a48ef..f331f8ec7b 100644
--- a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
+++ b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
@@ -1,490 +1,490 @@
 /*===================================================================
 
 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 "mitkExtractDirectedPlaneImageFilter.h"
 #include "mitkAbstractTransformGeometry.h"
 //#include "mitkImageMapperGL2D.h"
 
 #include <mitkProperties.h>
 #include <mitkDataNode.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkResliceMethodProperty.h>
 #include "vtkMitkThickSlicesFilter.h"
 
 #include <vtkTransform.h>
 #include <vtkGeneralTransform.h>
 #include <vtkImageData.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkPoints.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 
 
 mitk::ExtractDirectedPlaneImageFilter::ExtractDirectedPlaneImageFilter()
 : m_WorldGeometry(NULL)
 {
   MITK_WARN << "Class ExtractDirectedPlaneImageFilter is deprecated! Use ExtractSliceFilter instead.";
 
   m_Reslicer = vtkImageReslice::New();
 
   m_TargetTimestep = 0;
   m_InPlaneResampleExtentByGeometry = true;
   m_ResliceInterpolationProperty = NULL;//VtkResliceInterpolationProperty::New(); //TODO initial with value
     m_ThickSlicesMode = 0;
   m_ThickSlicesNum = 1;
 }
 
 mitk::ExtractDirectedPlaneImageFilter::~ExtractDirectedPlaneImageFilter()
 {
   if(m_ResliceInterpolationProperty!=NULL)m_ResliceInterpolationProperty->Delete();
   m_Reslicer->Delete();
 }
 
 void mitk::ExtractDirectedPlaneImageFilter::GenerateData()
 {
   // A world geometry must be set...
   if ( m_WorldGeometry == NULL )
   {
     itkWarningMacro(<<"No world geometry has been set. Returning.");
     return;
   }
 
   Image *input = const_cast< ImageToImageFilter::InputImageType* >( this->GetInput() );
   input->Update();
 
   if ( input == NULL )
   {
     itkWarningMacro(<<"No input set.");
     return;
   }
 
   const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
   if ( ( inputTimeGeometry == NULL )
     || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
   {
     itkWarningMacro(<<"Error reading input image geometry.");
     return;
   }
 
   // Get the target timestep; if none is set, use the lowest given.
   unsigned int timestep = 0;
   if ( ! m_TargetTimestep )
   {
     ScalarType time = m_WorldGeometry->GetTimeBounds()[0];
     if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
     {
       timestep = inputTimeGeometry->TimePointToTimeStep( time );
     }
   }
   else timestep = m_TargetTimestep;
 
   if ( inputTimeGeometry->IsValidTimeStep( timestep ) == false )
   {
     itkWarningMacro(<<"This is not a valid timestep: "<<timestep);
     return;
   }
 
   // check if there is something to display.
   if ( ! input->IsVolumeSet( timestep ) )
   {
     itkWarningMacro(<<"No volume data existent at given timestep "<<timestep);
     return;
   }
 
   Image::RegionType requestedRegion = input->GetLargestPossibleRegion();
   requestedRegion.SetIndex( 3, timestep );
   requestedRegion.SetSize( 3, 1 );
   requestedRegion.SetSize( 4, 1 );
   input->SetRequestedRegion( &requestedRegion );
   input->Update();
 
   vtkImageData* inputData = input->GetVtkImageData( timestep );
 
   if ( inputData == NULL )
   {
     itkWarningMacro(<<"Could not extract vtk image data for given timestep"<<timestep);
     return;
   }
 
   double spacing[3];
   inputData->GetSpacing( spacing );
 
   // how big the area is in physical coordinates: widthInMM x heightInMM pixels
   mitk::ScalarType widthInMM, heightInMM;
 
   // where we want to sample
   Point3D origin;
   Vector3D right, bottom, normal;
   Vector3D rightInIndex, bottomInIndex;
 
   assert( input->GetTimeGeometry() == inputTimeGeometry );
 
   // take transform of input image into account
   BaseGeometry* inputGeometry = inputTimeGeometry->GetGeometryForTimeStep( timestep );
   if ( inputGeometry == NULL )
   {
     itkWarningMacro(<<"There is no Geometry3D at given timestep "<<timestep);
     return;
   }
 
   ScalarType mmPerPixel[2];
 
   // Bounds information for reslicing (only required if reference geometry
   // is present)
   double bounds[6];
   bool boundsInitialized = false;
 
   for ( int i = 0; i < 6; ++i )
   {
     bounds[i] = 0.0;
   }
 
   Vector2D extent; extent.Fill( 0.0 );
 
   // Do we have a simple PlaneGeometry?
   if ( dynamic_cast< const PlaneGeometry * >( m_WorldGeometry ) != NULL )
   {
     const PlaneGeometry *planeGeometry =
       static_cast< const PlaneGeometry * >( m_WorldGeometry );
     origin = planeGeometry->GetOrigin();
     right  = planeGeometry->GetAxisVector( 0 );
     bottom = planeGeometry->GetAxisVector( 1 );
     normal = planeGeometry->GetNormal();
 
     if ( m_InPlaneResampleExtentByGeometry )
     {
       // Resampling grid corresponds to the current world geometry. This
       // means that the spacing of the output 2D image depends on the
       // currently selected world geometry, and *not* on the image itself.
 
       extent[0] = m_WorldGeometry->GetExtent( 0 );
       extent[1] = m_WorldGeometry->GetExtent( 1 );
     }
     else
     {
       // Resampling grid corresponds to the input geometry. This means that
       // the spacing of the output 2D image is directly derived from the
       // associated input image, regardless of the currently selected world
       // geometry.
       inputGeometry->WorldToIndex( right, rightInIndex );
       inputGeometry->WorldToIndex( bottom, bottomInIndex );
       extent[0] = rightInIndex.GetNorm();
       extent[1] = bottomInIndex.GetNorm();
     }
 
     // Get the extent of the current world geometry and calculate resampling
     // spacing therefrom.
     widthInMM = m_WorldGeometry->GetExtentInMM( 0 );
     heightInMM = m_WorldGeometry->GetExtentInMM( 1 );
 
     mmPerPixel[0] = widthInMM / extent[0];
     mmPerPixel[1] = heightInMM / extent[1];
 
     right.Normalize();
     bottom.Normalize();
     normal.Normalize();
 
     //origin += right * ( mmPerPixel[0] * 0.5 );
     //origin += bottom * ( mmPerPixel[1] * 0.5 );
 
     //widthInMM -= mmPerPixel[0];
     //heightInMM -= mmPerPixel[1];
 
     // Use inverse transform of the input geometry for reslicing the 3D image
     m_Reslicer->SetResliceTransform(
       inputGeometry->GetVtkTransform()->GetLinearInverse() );
 
-    // Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D)
+    // Set background level to TRANSLUCENT (see PlaneGeometryDataVtkMapper3D)
     m_Reslicer->SetBackgroundLevel( -32768 );
 
     // Check if a reference geometry does exist (as would usually be the case for
     // PlaneGeometry).
     // Note: this is currently not strictly required, but could facilitate
     // correct plane clipping.
     if ( m_WorldGeometry->GetReferenceGeometry() )
     {
       // 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.
       boundsInitialized = this->CalculateClippedPlaneBounds(
         m_WorldGeometry->GetReferenceGeometry(), planeGeometry, bounds );
     }
   }
 
   // Do we have an AbstractTransformGeometry?
   else if ( dynamic_cast< const AbstractTransformGeometry * >( m_WorldGeometry ) )
   {
     const mitk::AbstractTransformGeometry* abstractGeometry =
       dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry);
 
     extent[0] = abstractGeometry->GetParametricExtent(0);
     extent[1] = abstractGeometry->GetParametricExtent(1);
 
     widthInMM = abstractGeometry->GetParametricExtentInMM(0);
     heightInMM = abstractGeometry->GetParametricExtentInMM(1);
 
     mmPerPixel[0] = widthInMM / extent[0];
     mmPerPixel[1] = heightInMM / extent[1];
 
     origin = abstractGeometry->GetPlane()->GetOrigin();
 
     right = abstractGeometry->GetPlane()->GetAxisVector(0);
     right.Normalize();
 
     bottom = abstractGeometry->GetPlane()->GetAxisVector(1);
     bottom.Normalize();
 
     normal = abstractGeometry->GetPlane()->GetNormal();
     normal.Normalize();
 
     // Use a combination of the InputGeometry *and* the possible non-rigid
     // AbstractTransformGeometry for reslicing the 3D Image
     vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New();
     composedResliceTransform->Identity();
     composedResliceTransform->Concatenate(
       inputGeometry->GetVtkTransform()->GetLinearInverse() );
     composedResliceTransform->Concatenate(
       abstractGeometry->GetVtkAbstractTransform()
       );
 
     m_Reslicer->SetResliceTransform( composedResliceTransform );
 
     // Set background level to BLACK instead of translucent, to avoid
-    // boundary artifacts (see Geometry2DDataVtkMapper3D)
+    // boundary artifacts (see PlaneGeometryDataVtkMapper3D)
     m_Reslicer->SetBackgroundLevel( -1023 );
     composedResliceTransform->Delete();
   }
   else
   {
     itkWarningMacro(<<"World Geometry has to be a PlaneGeometry or an AbstractTransformGeometry.");
     return;
   }
 
   // Make sure that the image to be resliced has a certain minimum size.
   if ( (extent[0] <= 2) && (extent[1] <= 2) )
   {
     itkWarningMacro(<<"Image is too small to be resliced...");
     return;
   }
 
   vtkSmartPointer<vtkImageChangeInformation> unitSpacingImageFilter = vtkImageChangeInformation::New() ;
   unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
   unitSpacingImageFilter->SetInputData( inputData );
 
   m_Reslicer->SetInputConnection( unitSpacingImageFilter->GetOutputPort() );
 
   //m_Reslicer->SetInput( inputData );
 
   m_Reslicer->SetOutputDimensionality( 2 );
   m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 );
 
   Vector2D pixelsPerMM;
   pixelsPerMM[0] = 1.0 / mmPerPixel[0];
   pixelsPerMM[1] = 1.0 / mmPerPixel[1];
 
   //calulate the originArray and the orientations for the reslice-filter
   double originArray[3];
   itk2vtk( origin, originArray );
 
   m_Reslicer->SetResliceAxesOrigin( originArray );
 
   double cosines[9];
 
   // direction of the X-axis of the sampled result
   vnl2vtk( right.GetVnlVector(), cosines );
 
   // direction of the Y-axis of the sampled result
   vnl2vtk( bottom.GetVnlVector(), cosines + 3 );
 
   // normal of the plane
   vnl2vtk( normal.GetVnlVector(), cosines + 6 );
 
   m_Reslicer->SetResliceAxesDirectionCosines( cosines );
 
   int xMin, xMax, yMin, yMax;
   if ( boundsInitialized )
   {
     xMin = static_cast< int >( bounds[0] / mmPerPixel[0] );//+ 0.5 );
     xMax = static_cast< int >( bounds[1] / mmPerPixel[0] );//+ 0.5 );
     yMin = static_cast< int >( bounds[2] / mmPerPixel[1] );//+ 0.5);
     yMax = static_cast< int >( bounds[3] / mmPerPixel[1] );//+ 0.5 );
   }
   else
   {
     // If no reference geometry is available, we also don't know about the
     // maximum plane size; so the overlap is just ignored
 
     xMin = yMin = 0;
     xMax = static_cast< int >( extent[0] - pixelsPerMM[0] );//+ 0.5 );
     yMax = static_cast< int >( extent[1] - pixelsPerMM[1] );//+ 0.5 );
   }
 
   m_Reslicer->SetOutputSpacing( mmPerPixel[0], mmPerPixel[1], 1.0 );
   // xMax and yMax are meant exclusive until now, whereas
   // SetOutputExtent wants an inclusive bound. Thus, we need
   // to subtract 1.
   m_Reslicer->SetOutputExtent( xMin, xMax-1, yMin, yMax-1, 0, 1 );
 
   // 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.
   m_Reslicer->Modified();
   m_Reslicer->ReleaseDataFlagOn();
 
   m_Reslicer->Update();
 
   // 1. Check the result
   vtkImageData* reslicedImage = m_Reslicer->GetOutput();
 
   if((reslicedImage == NULL) || (reslicedImage->GetDataDimension() < 1))
   {
     itkWarningMacro(<<"Reslicer returned empty image");
     return;
   }
 
   unsigned int dimensions[2];
   dimensions[0] = (unsigned int)extent[0]; dimensions[1] = (unsigned int)extent[1];
   Vector3D spacingVector;
   FillVector3D(spacingVector, mmPerPixel[0], mmPerPixel[1], 1.0);
 
   mitk::Image::Pointer resultImage = this->GetOutput();
   resultImage->Initialize(input->GetPixelType(), 2, dimensions );
   resultImage->SetSpacing( spacingVector );
 }
 
 
 void mitk::ExtractDirectedPlaneImageFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
 
 
 bool mitk::ExtractDirectedPlaneImageFilter
 ::CalculateClippedPlaneBounds( const BaseGeometry *boundingGeometry,
                 const PlaneGeometry *planeGeometry, double *bounds )
 {
   // Clip the plane with the bounding geometry. To do so, the corner points
   // of the bounding box are transformed by the inverse transformation
   // matrix, and the transformed bounding box edges derived therefrom are
   // clipped with the plane z=0. The resulting min/max values are taken as
   // bounds for the image reslicer.
   const BoundingBox *boundingBox = boundingGeometry->GetBoundingBox();
 
   BoundingBox::PointType bbMin = boundingBox->GetMinimum();
   BoundingBox::PointType bbMax = boundingBox->GetMaximum();
 
   vtkPoints *points = vtkPoints::New();
   if(boundingGeometry->GetImageGeometry())
   {
     points->InsertPoint( 0, bbMin[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 );
     points->InsertPoint( 1, bbMin[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 );
     points->InsertPoint( 2, bbMin[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 );
     points->InsertPoint( 3, bbMin[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 );
     points->InsertPoint( 4, bbMax[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 );
     points->InsertPoint( 5, bbMax[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 );
     points->InsertPoint( 6, bbMax[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 );
     points->InsertPoint( 7, bbMax[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 );
   }
   else
   {
     points->InsertPoint( 0, bbMin[0], bbMin[1], bbMin[2] );
     points->InsertPoint( 1, bbMin[0], bbMin[1], bbMax[2] );
     points->InsertPoint( 2, bbMin[0], bbMax[1], bbMax[2] );
     points->InsertPoint( 3, bbMin[0], bbMax[1], bbMin[2] );
     points->InsertPoint( 4, bbMax[0], bbMin[1], bbMin[2] );
     points->InsertPoint( 5, bbMax[0], bbMin[1], bbMax[2] );
     points->InsertPoint( 6, bbMax[0], bbMax[1], bbMax[2] );
     points->InsertPoint( 7, bbMax[0], bbMax[1], bbMin[2] );
   }
 
   vtkPoints *newPoints = vtkPoints::New();
 
   vtkTransform *transform = vtkTransform::New();
   transform->Identity();
   transform->Concatenate(
     planeGeometry->GetVtkTransform()->GetLinearInverse()
     );
 
   transform->Concatenate( boundingGeometry->GetVtkTransform() );
 
   transform->TransformPoints( points, newPoints );
   transform->Delete();
 
   bounds[0] = bounds[2] = 10000000.0;
   bounds[1] = bounds[3] = -10000000.0;
   bounds[4] = bounds[5] = 0.0;
 
   this->LineIntersectZero( newPoints, 0, 1, bounds );
   this->LineIntersectZero( newPoints, 1, 2, bounds );
   this->LineIntersectZero( newPoints, 2, 3, bounds );
   this->LineIntersectZero( newPoints, 3, 0, bounds );
   this->LineIntersectZero( newPoints, 0, 4, bounds );
   this->LineIntersectZero( newPoints, 1, 5, bounds );
   this->LineIntersectZero( newPoints, 2, 6, bounds );
   this->LineIntersectZero( newPoints, 3, 7, bounds );
   this->LineIntersectZero( newPoints, 4, 5, bounds );
   this->LineIntersectZero( newPoints, 5, 6, bounds );
   this->LineIntersectZero( newPoints, 6, 7, bounds );
   this->LineIntersectZero( newPoints, 7, 4, bounds );
 
   // clean up vtk data
   points->Delete();
   newPoints->Delete();
 
   if ( (bounds[0] > 9999999.0) || (bounds[2] > 9999999.0)
     || (bounds[1] < -9999999.0) || (bounds[3] < -9999999.0) )
   {
     return false;
   }
   else
   {
     // The resulting bounds must be adjusted by the plane spacing, since we
     // we have so far dealt with index coordinates
     const mitk::Vector3D planeSpacing = planeGeometry->GetSpacing();
     bounds[0] *= planeSpacing[0];
     bounds[1] *= planeSpacing[0];
     bounds[2] *= planeSpacing[1];
     bounds[3] *= planeSpacing[1];
     bounds[4] *= planeSpacing[2];
     bounds[5] *= planeSpacing[2];
     return true;
   }
 }
 
 bool mitk::ExtractDirectedPlaneImageFilter
 ::LineIntersectZero( vtkPoints *points, int p1, int p2,
           double *bounds )
 {
   double point1[3];
   double point2[3];
   points->GetPoint( p1, point1 );
   points->GetPoint( p2, point2 );
 
   if ( (point1[2] * point2[2] <= 0.0) && (point1[2] != point2[2]) )
   {
     double x, y;
     x = ( point1[0] * point2[2] - point1[2] * point2[0] ) / ( point2[2] - point1[2] );
     y = ( point1[1] * point2[2] - point1[2] * point2[1] ) / ( point2[2] - point1[2] );
 
     if ( x < bounds[0] ) { bounds[0] = x; }
     if ( x > bounds[1] ) { bounds[1] = x; }
     if ( y < bounds[2] ) { bounds[2] = y; }
     if ( y > bounds[3] ) { bounds[3] = y; }
     bounds[4] = bounds[5] = 0.0;
     return true;
   }
   return false;
 }
diff --git a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.cpp b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.cpp
index f416051d0d..716e202c8a 100644
--- a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.cpp
+++ b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.cpp
@@ -1,297 +1,297 @@
 /*===================================================================
 
 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 "mitkExtractDirectedPlaneImageFilterNew.h"
 #include "mitkImageCast.h"
 #include "mitkImageTimeSelector.h"
 #include "itkImageRegionIterator.h"
 
 #include <mitkImageAccessByItk.h>
 
 mitk::ExtractDirectedPlaneImageFilterNew::ExtractDirectedPlaneImageFilterNew()
-:m_CurrentWorldGeometry2D(NULL),
+:m_CurrentWorldPlaneGeometry(NULL),
 m_ActualInputTimestep(-1)
 {
   MITK_WARN << "Class ExtractDirectedPlaneImageFilterNew is deprecated! Use ExtractSliceFilter instead.";
 }
 
 mitk::ExtractDirectedPlaneImageFilterNew::~ExtractDirectedPlaneImageFilterNew()
 {
 }
 
 void mitk::ExtractDirectedPlaneImageFilterNew::GenerateData(){
 
     mitk::Image::ConstPointer inputImage = ImageToImageFilter::GetInput(0);
 
     if ( !inputImage )
     {
         MITK_ERROR << "mitk::ExtractDirectedPlaneImageFilterNew: No input available. Please set the input!" << std::endl;
         itkExceptionMacro("mitk::ExtractDirectedPlaneImageFilterNew: No input available. Please set the input!");
         return;
     }
 
     m_ImageGeometry = inputImage->GetGeometry();
 
     //If no timestep is set, the lowest given will be selected
     const mitk::TimeGeometry* inputTimeGeometry = this->GetInput()->GetTimeGeometry();
     if ( m_ActualInputTimestep == -1)
     {
-        ScalarType time = m_CurrentWorldGeometry2D->GetTimeBounds()[0];
+        ScalarType time = m_CurrentWorldPlaneGeometry->GetTimeBounds()[0];
         if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
         {
             m_ActualInputTimestep = inputTimeGeometry->TimePointToTimeStep( time );
         }
     }
 
     if ( inputImage->GetDimension() > 4 || inputImage->GetDimension() < 2)
     {
         MITK_ERROR << "mitk::ExtractDirectedPlaneImageFilterNew:GenerateData works only with 3D and 3D+t images, sorry." << std::endl;
         itkExceptionMacro("mitk::ExtractDirectedPlaneImageFilterNew works only with 3D and 3D+t images, sorry.");
         return;
     }
     else if ( inputImage->GetDimension() == 4 )
     {
         mitk::ImageTimeSelector::Pointer timeselector = mitk::ImageTimeSelector::New();
         timeselector->SetInput( inputImage );
         timeselector->SetTimeNr( m_ActualInputTimestep );
         timeselector->UpdateLargestPossibleRegion();
         inputImage = timeselector->GetOutput();
     }
     else if ( inputImage->GetDimension() == 2)
     {
         mitk::Image::Pointer resultImage = ImageToImageFilter::GetOutput();
         resultImage = const_cast<mitk::Image*>( inputImage.GetPointer() );
         ImageToImageFilter::SetNthOutput( 0, resultImage);
         return;
     }
 
-    if ( !m_CurrentWorldGeometry2D )
+    if ( !m_CurrentWorldPlaneGeometry )
     {
-        MITK_ERROR<< "mitk::ExtractDirectedPlaneImageFilterNew::GenerateData has no CurrentWorldGeometry2D set" << std::endl;
+        MITK_ERROR<< "mitk::ExtractDirectedPlaneImageFilterNew::GenerateData has no CurrentWorldPlaneGeometry set" << std::endl;
         return;
     }
 
     AccessFixedDimensionByItk( inputImage, ItkSliceExtraction, 3 );
 
 }//Generate Data
 
 
 void mitk::ExtractDirectedPlaneImageFilterNew::GenerateOutputInformation ()
 {
     Superclass::GenerateOutputInformation();
 }
 
 
 
 /*
 * The desired slice is extracted by filling the image`s corresponding pixel values in an empty 2 dimensional itk::Image
 * Therefor the itk image`s extent in pixel (in each direction) is doubled and its spacing (also in each direction) is divided by two
 * (similar to the shannon theorem).
 */
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::ExtractDirectedPlaneImageFilterNew::ItkSliceExtraction (itk::Image<TPixel, VImageDimension>* inputImage)
 {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::Image<TPixel, VImageDimension-1> SliceImageType;
 
     typedef itk::ImageRegionConstIterator< SliceImageType > SliceIterator;
 
     //Creating an itk::Image that represents the sampled slice
     typename SliceImageType::Pointer resultSlice = SliceImageType::New();
 
     typename SliceImageType::IndexType start;
 
     start[0] = 0;
     start[1] = 0;
 
-    Point3D origin = m_CurrentWorldGeometry2D->GetOrigin();
-    Vector3D right = m_CurrentWorldGeometry2D->GetAxisVector(0);
-    Vector3D bottom = m_CurrentWorldGeometry2D->GetAxisVector(1);
+    Point3D origin = m_CurrentWorldPlaneGeometry->GetOrigin();
+    Vector3D right = m_CurrentWorldPlaneGeometry->GetAxisVector(0);
+    Vector3D bottom = m_CurrentWorldPlaneGeometry->GetAxisVector(1);
 
     //Calculation the sample-spacing, i.e the half of the smallest spacing existing in the original image
     Vector3D newPixelSpacing = m_ImageGeometry->GetSpacing();
     float minSpacing = newPixelSpacing[0];
     for (unsigned int i = 1; i < newPixelSpacing.Size(); i++)
     {
         if (newPixelSpacing[i] < minSpacing )
         {
             minSpacing = newPixelSpacing[i];
         }
     }
 
     newPixelSpacing[0] = 0.5*minSpacing;
     newPixelSpacing[1] = 0.5*minSpacing;
     newPixelSpacing[2] = 0.5*minSpacing;
 
     float pixelSpacing[2];
     pixelSpacing[0] =  newPixelSpacing[0];
     pixelSpacing[1] =  newPixelSpacing[1];
 
     //Calculating the size of the sampled slice
     typename SliceImageType::SizeType size;
     Vector2D extentInMM;
-    extentInMM[0] = m_CurrentWorldGeometry2D->GetExtentInMM(0);
-    extentInMM[1] = m_CurrentWorldGeometry2D->GetExtentInMM(1);
+    extentInMM[0] = m_CurrentWorldPlaneGeometry->GetExtentInMM(0);
+    extentInMM[1] = m_CurrentWorldPlaneGeometry->GetExtentInMM(1);
 
     //The maximum extent is the lenght of the diagonal of the considered plane
     double maxExtent = sqrt(extentInMM[0]*extentInMM[0]+extentInMM[1]*extentInMM[1]);
     unsigned int xTranlation = (maxExtent-extentInMM[0]);
     unsigned int yTranlation = (maxExtent-extentInMM[1]);
     size[0] = (maxExtent+xTranlation)/newPixelSpacing[0];
     size[1] = (maxExtent+yTranlation)/newPixelSpacing[1];
 
     //Creating an ImageRegion Object
     typename SliceImageType::RegionType region;
 
     region.SetSize( size );
     region.SetIndex( start );
 
     //Defining the image`s extent and origin by passing the region to it and allocating memory for it
     resultSlice->SetRegions( region );
     resultSlice->SetSpacing( pixelSpacing );
     resultSlice->Allocate();
 
     /*
     * Here we create an new geometry so that the transformations are calculated correctly (our resulting slice has a different bounding box and spacing)
     * The original current worldgeometry must be cloned because we have to keep the directions of the axis vector which represents the rotation
     */
     right.Normalize();
     bottom.Normalize();
     //Here we translate the origin to adapt the new geometry to the previous calculated extent
     origin[0] -= xTranlation*right[0]+yTranlation*bottom[0];
     origin[1] -= xTranlation*right[1]+yTranlation*bottom[1];
     origin[2] -= xTranlation*right[2]+yTranlation*bottom[2];
 
     //Putting it together for the new geometry
-    mitk::BaseGeometry::Pointer newSliceGeometryTest = dynamic_cast<BaseGeometry*>(m_CurrentWorldGeometry2D->Clone().GetPointer());
+    mitk::BaseGeometry::Pointer newSliceGeometryTest = dynamic_cast<BaseGeometry*>(m_CurrentWorldPlaneGeometry->Clone().GetPointer());
     newSliceGeometryTest->ChangeImageGeometryConsideringOriginOffset(true);
 
     //Workaround because of BUG (#6505)
-    newSliceGeometryTest->GetIndexToWorldTransform()->SetMatrix(m_CurrentWorldGeometry2D->GetIndexToWorldTransform()->GetMatrix());
+    newSliceGeometryTest->GetIndexToWorldTransform()->SetMatrix(m_CurrentWorldPlaneGeometry->GetIndexToWorldTransform()->GetMatrix());
     //Workaround end
 
     newSliceGeometryTest->SetOrigin(origin);
     ScalarType bounds[6]={0, static_cast<ScalarType>(size[0]), 0, static_cast<ScalarType>(size[1]), 0, 1};
     newSliceGeometryTest->SetBounds(bounds);
     newSliceGeometryTest->SetSpacing(newPixelSpacing);
     newSliceGeometryTest->Modified();
 
     //Workaround because of BUG (#6505)
     itk::MatrixOffsetTransformBase<mitk::ScalarType,3,3>::MatrixType tempTransform = newSliceGeometryTest->GetIndexToWorldTransform()->GetMatrix();
     //Workaround end
 
     /*
     * Now we iterate over the recently created slice.
     * For each slice - pixel we check whether there is an according
     * pixel in the input - image which can be set in the slice.
     * In this way a slice is sampled out of the input - image regrading to the given PlaneGeometry
     */
     Point3D currentSliceIndexPointIn2D;
     Point3D currentImageWorldPointIn3D;
     typename InputImageType::IndexType inputIndex;
 
     SliceIterator sliceIterator ( resultSlice, resultSlice->GetLargestPossibleRegion() );
     sliceIterator.GoToBegin();
 
     while ( !sliceIterator.IsAtEnd() )
     {
         /*
         * Here we add 0.5 to to assure that the indices are correctly transformed.
         * (Because of the 0.5er Bug)
         */
         currentSliceIndexPointIn2D[0] = sliceIterator.GetIndex()[0]+0.5;
         currentSliceIndexPointIn2D[1] = sliceIterator.GetIndex()[1]+0.5;
         currentSliceIndexPointIn2D[2] = 0;
 
         newSliceGeometryTest->IndexToWorld( currentSliceIndexPointIn2D, currentImageWorldPointIn3D );
 
         m_ImageGeometry->WorldToIndex( currentImageWorldPointIn3D, inputIndex);
 
         if ( m_ImageGeometry->IsIndexInside( inputIndex ))
         {
 
             resultSlice->SetPixel( sliceIterator.GetIndex(), inputImage->GetPixel(inputIndex) );
 
         }
         else
         {
             resultSlice->SetPixel( sliceIterator.GetIndex(), 0);
         }
 
         ++sliceIterator;
     }
 
     Image::Pointer resultImage = ImageToImageFilter::GetOutput();
     GrabItkImageMemory(resultSlice, resultImage, NULL, false);
     resultImage->SetClonedGeometry(newSliceGeometryTest);
     //Workaround because of BUG (#6505)
     resultImage->GetGeometry()->GetIndexToWorldTransform()->SetMatrix(tempTransform);
     //Workaround end
 }
 
 
 ///**TEST** May ba a little bit more efficient but doesn`t already work/
 //right.Normalize();
 //bottom.Normalize();
 //Point3D currentImagePointIn3D = origin /*+ bottom*newPixelSpacing*/;
 //unsigned int columns ( 0 );
 /**ENDE**/
 
 
 /****TEST***/
 
 //SliceImageType::IndexType index = sliceIterator.GetIndex();
 
 //if ( columns == (extentInPixel[0]) )
 //{
 //If we are at the end of a row, then we have to go to the beginning of the next row
 //currentImagePointIn3D = origin;
 //currentImagePointIn3D += newPixelSpacing[1]*bottom*index[1];
 //columns = 0;
 //m_ImageGeometry->WorldToIndex(currentImagePointIn3D, inputIndex);
 //}
 //else
 //{
 ////
 //if ( columns != 0 )
 //{
 //currentImagePointIn3D += newPixelSpacing[0]*right;
 //}
 //m_ImageGeometry->WorldToIndex(currentImagePointIn3D, inputIndex);
 //}
 
 //if ( m_ImageGeometry->IsIndexInside( inputIndex ))
 //{
 //resultSlice->SetPixel( sliceIterator.GetIndex(), inputImage->GetPixel(inputIndex) );
 //}
 //else if (currentImagePointIn3D == origin)
 //{
 //Point3D temp;
 //temp[0] = bottom[0]*newPixelSpacing[0]*0.5;
 //temp[1] = bottom[1]*newPixelSpacing[1]*0.5;
 //temp[2] = bottom[2]*newPixelSpacing[2]*0.5;
 //origin[0] += temp[0];
 //origin[1] += temp[1];
 //origin[2] += temp[2];
 //currentImagePointIn3D = origin;
 //m_ImageGeometry->WorldToIndex(currentImagePointIn3D, inputIndex);
 //if ( m_ImageGeometry->IsIndexInside( inputIndex ))
 //{
 //resultSlice->SetPixel( sliceIterator.GetIndex(), inputImage->GetPixel(inputIndex) );
 //}
 //}
 
 /****TEST ENDE****/
diff --git a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.h b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.h
index aaa2708314..f3cb66d4ad 100644
--- a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.h
+++ b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilterNew.h
@@ -1,97 +1,97 @@
 /*===================================================================
 
 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 mitkExtractDirectedPlaneImageFilterNew_h_Included
 #define mitkExtractDirectedPlaneImageFilterNew_h_Included
 
 #include <MitkImageExtractionExports.h>
 #include "mitkImageToImageFilter.h"
 #include "itkImage.h"
 #include "mitkITKImageImport.h"
 
 namespace mitk {
 
 /**
   \deprecated This class is deprecated. Use mitk::ExtractSliceFilter instead.
   \sa ExtractSliceFilter
 
   \brief A filter that can extract a 2D slice from a 3D or 4D image especially if the image`s axes are rotated
 
   \sa ContourTool
   \sa SegTool2D
   \sa ExtractImageFilter
   \sa OverwriteSliceImageFilter
   \sa OverwriteDirectedPlaneImageFilter
 
   \ingroup Process
   \ingroup Reliver
 
   There is a separate page describing the general design of QmitkInteractiveSegmentation: \ref QmitkSegmentationTechnicalPage
 
   This class takes an 3D or 4D mitk::Image as input and extracts a slice from it. If you work with a 4D image as input you have to specify the
   desired timestep at which the slice shall be extracted, otherwise the lowest given timestep is selected by default.
 
   The special feature of this filter is, that the planes of the input image can be rotated in any way. To assure a proper extraction you have to
-  set the currentWorldGeometry2D with you can obtain from the BaseRenderer, respectively the positionEvent send by the renderer.
+  set the currentWorldPlaneGeometry with you can obtain from the BaseRenderer, respectively the positionEvent send by the renderer.
 
   The output will not be set if there was a problem with the input image
 
   $Author: fetzer $
 */
 class MitkImageExtraction_EXPORT ExtractDirectedPlaneImageFilterNew : public ImageToImageFilter
 {
 
 public:
 
     mitkClassMacro(ExtractDirectedPlaneImageFilterNew, ImageToImageFilter);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /**
       \brief Set macro for the current worldgeometry
 
       \a Parameter The current wordgeometry that describes the position (rotation, translation)
          of the plane (and therefore the slice to be extracted) in our 3D(+t) image
     */
-    itkSetMacro(CurrentWorldGeometry2D, BaseGeometry* );
+    itkSetMacro(CurrentWorldPlaneGeometry, BaseGeometry* );
 
     itkSetMacro(ImageGeometry, BaseGeometry* );
 
     /**
       \brief Set macro for the current timestep
 
       \a Parameter The timestep of the image from which the slice shall be extracted
     */
     itkSetMacro(ActualInputTimestep, int);
 
 protected:
     ExtractDirectedPlaneImageFilterNew();
     virtual ~ExtractDirectedPlaneImageFilterNew();
     virtual void GenerateData();
     virtual void GenerateOutputInformation();
 
 private:
-    const BaseGeometry* m_CurrentWorldGeometry2D;
+    const BaseGeometry* m_CurrentWorldPlaneGeometry;
     const BaseGeometry* m_ImageGeometry;
     int m_ActualInputTimestep;
 
     template<typename TPixel, unsigned int VImageDimension>
     void ItkSliceExtraction (itk::Image<TPixel, VImageDimension>* inputImage);
 };
 
 }//namespace
 
 #endif
diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
index 2311d5a0d9..33168ae0e9 100644
--- a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
@@ -1,409 +1,409 @@
 /*===================================================================
 
 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 "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 
 #include "mitkImageStatisticsCalculator.h"
 #include "mitkPlanarPolygon.h"
 
 #include "mitkDicomSeriesReader.h"
 
 /**
  * \brief Test class for mitkImageStatisticsCalculator
  *
  * This test covers:
  * - instantiation of an ImageStatisticsCalculator class
  * - correctness of statistics when using PlanarFigures for masking
  */
 class mitkImageStatisticsCalculatorTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkImageStatisticsCalculatorTestSuite);
   MITK_TEST(TestUninitializedImage);
   MITK_TEST(TestCase1);
   MITK_TEST(TestCase2);
   MITK_TEST(TestCase3);
   MITK_TEST(TestCase4);
   MITK_TEST(TestCase5);
   MITK_TEST(TestCase6);
   MITK_TEST(TestCase7);
   MITK_TEST(TestCase8);
   MITK_TEST(TestCase9);
   MITK_TEST(TestCase10);
   MITK_TEST(TestCase11);
   MITK_TEST(TestCase12);
   CPPUNIT_TEST_SUITE_END();
 
 public:
 
   void setUp();
 
   void TestUninitializedImage();
 
   void TestCase1();
   void TestCase2();
   void TestCase3();
   void TestCase4();
   void TestCase5();
   void TestCase6();
   void TestCase7();
   void TestCase8();
   void TestCase9();
   void TestCase10();
   void TestCase11();
   void TestCase12();
 
 private:
 
   mitk::Image::Pointer m_Image;
   mitk::PlaneGeometry::Pointer m_Geometry;
 
   // calculate statistics for the given image and planarpolygon
   const mitk::ImageStatisticsCalculator::Statistics ComputeStatistics( mitk::Image::Pointer image,
                                                                        mitk::PlanarFigure::Pointer polygon );
 
   void VerifyStatistics(const mitk::ImageStatisticsCalculator::Statistics& stats,
                         double testMean, double testSD);
 };
 
 void mitkImageStatisticsCalculatorTestSuite::setUp()
 {
   std::string filename = this->GetTestDataFilePath("ImageStatistics/testimage.dcm");
   if (filename.empty())
   {
     MITK_TEST_FAILED_MSG( << "Could not find test file" )
   }
 
   mitk::DicomSeriesReader::StringContainer file;
   file.push_back( filename );
 
   mitk::DicomSeriesReader* reader = new mitk::DicomSeriesReader;
 
   mitk::DataNode::Pointer node = reader->LoadDicomSeries( file, false, false );
   m_Image = dynamic_cast<mitk::Image*>( node->GetData() );
 
   MITK_TEST_CONDITION_REQUIRED( m_Image.IsNotNull(), "Loading test image" )
 
-  m_Geometry = m_Image->GetSlicedGeometry()->GetGeometry2D(0);
+  m_Geometry = m_Image->GetSlicedGeometry()->GetPlaneGeometry(0);
   MITK_TEST_CONDITION_REQUIRED( m_Geometry.IsNotNull(), "Getting image geometry" )
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase1()
 {
   /*****************************
    * one whole white pixel
    * -> mean of 255 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
-  figure1->SetGeometry2D( m_Geometry );
+  figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 10.5; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 255.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase2()
 {
   /*****************************
    * half pixel in x-direction (white)
    * -> mean of 255 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
-  figure1->SetGeometry2D( m_Geometry );
+  figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 10.0 ; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 10.0; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 255.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase3()
 {
   /*****************************
    * half pixel in diagonal-direction (white)
    * -> mean of 255 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
-  figure1->SetGeometry2D( m_Geometry );
+  figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 255.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase4()
 {
   /*****************************
    * one pixel (white) + 2 half pixels (white) + 1 half pixel (black)
    * -> mean of 191.25 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
-  figure1->SetGeometry2D( m_Geometry );
+  figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 1.1; pnt1[1] = 1.1;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 2.0; pnt2[1] = 2.0;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 3.0; pnt3[1] = 1.0;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 2.0; pnt4[1] = 0.0;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 191.25, 127.5);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase5()
 {
   /*****************************
    * whole pixel (white) + half pixel (gray) in x-direction
    * -> mean of 191.5 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
-  figure1->SetGeometry2D( m_Geometry );
+  figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 191.50, 89.80);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase6()
 {
   /*****************************
    * quarter pixel (black) + whole pixel (white) + half pixel (gray) in x-direction
    * -> mean of 191.5 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
-  figure1->SetGeometry2D( m_Geometry );
+  figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.25; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.25; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 191.5, 89.80);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase7()
 {
   /*****************************
    * half pixel (black) + whole pixel (white) + half pixel (gray) in x-direction
    * -> mean of 127.66 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
-  figure1->SetGeometry2D( m_Geometry );
+  figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.0; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.0; pnt3[1] = 4.0;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.0;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 127.66, 127.5);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase8()
 {
   /*****************************
    * whole pixel (gray)
    * -> mean of 128 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
-  figure2->SetGeometry2D( m_Geometry );
+  figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 11.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 11.5;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 128.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase9()
 {
   /*****************************
    * whole pixel (gray) + half pixel (white) in y-direction
    * -> mean of 191.5 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
-  figure2->SetGeometry2D( m_Geometry );
+  figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 12.0;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 12.0;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 191.5, 89.80);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase10()
 {
   /*****************************
    * 2 whole pixel (white) + 2 whole pixel (black) in y-direction
    * -> mean of 127.66 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
-  figure2->SetGeometry2D( m_Geometry );
+  figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 13.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 13.5;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 127.66, 127.5);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase11()
 {
   /*****************************
    * 9 whole pixels (white) + 3 half pixels (white)
    * + 3 whole pixel (black) [ + 3 slightly less than half pixels (black)]
    * -> mean of 204.0 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
-  figure2->SetGeometry2D( m_Geometry );
+  figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 0.5; pnt1[1] = 0.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 3.5; pnt2[1] = 3.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 8.4999; pnt3[1] = 3.5;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 5.4999; pnt4[1] = 0.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 204.0, 105.58 );
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase12()
 {
   /*****************************
    * half pixel (white) + whole pixel (white) + half pixel (black)
    * -> mean of 212.66 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
-  figure2->SetGeometry2D( m_Geometry );
+  figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 9.5; pnt1[1] = 0.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 2.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 11.5; pnt3[1] = 2.5;
   figure2->SetControlPoint( 2, pnt3, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 212.66, 73.32);
 }
 
 const mitk::ImageStatisticsCalculator::Statistics
 mitkImageStatisticsCalculatorTestSuite::ComputeStatistics( mitk::Image::Pointer image, mitk::PlanarFigure::Pointer polygon )
 {
   mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New();
   statisticsCalculator->SetImage( image );
   statisticsCalculator->SetMaskingModeToPlanarFigure();
   statisticsCalculator->SetPlanarFigure( polygon );
 
   statisticsCalculator->ComputeStatistics();
 
   return statisticsCalculator->GetStatistics();
 }
 
 void mitkImageStatisticsCalculatorTestSuite::VerifyStatistics(const mitk::ImageStatisticsCalculator::Statistics& stats,
                                                               double testMean, double testSD)
 {
   int tmpMean = stats.Mean * 100;
   double calculatedMean = tmpMean / 100.0;
   MITK_TEST_CONDITION( calculatedMean == testMean,
                        "Calculated mean grayvalue '" << calculatedMean <<
                        "'  is equal to the desired value '" << testMean << "'" );
 
   int tmpSD = stats.Sigma * 100;
   double calculatedSD = tmpSD / 100.0;
   MITK_TEST_CONDITION( calculatedSD == testSD,
                        "Calculated grayvalue sd '" << calculatedSD <<
                        "'  is equal to the desired value '" << testSD <<"'" );
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestUninitializedImage()
 {
   /*****************************
   * loading uninitialized image to datastorage
   ******************************/
   MITK_TEST_FOR_EXCEPTION_BEGIN(mitk::Exception)
   mitk::Image::Pointer image = mitk::Image::New();
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(image);
 
   mitk::ImageStatisticsCalculator::Pointer is = mitk::ImageStatisticsCalculator::New();
   is->ComputeStatistics();
   MITK_TEST_FOR_EXCEPTION_END(mitk::Exception)
 }
 
 MITK_TEST_SUITE_REGISTRATION(mitkImageStatisticsCalculator)
diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
index d8a5e7b94a..9f356b312e 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
@@ -1,1271 +1,1271 @@
 /*===================================================================
 
 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 "mitkImageStatisticsCalculator.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkExtractImageFilter.h"
 
 #include <itkScalarImageToHistogramGenerator.h>
 
 #include <itkChangeInformationImageFilter.h>
 #include <itkExtractImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 #include <itkStatisticsImageFilter.h>
 #include <itkLabelStatisticsImageFilter.h>
 #include <itkMaskImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRescaleIntensityImageFilter.h>
 
 
 #include <itkCastImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkImageDuplicator.h>
 
 
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkPolyData.h>
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkImageStencil.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageData.h>
 #include <vtkLassoStencilSource.h>
 #include <vtkMetaImageWriter.h>
 
 #include <list>
 
 #include <exception>
 
 namespace mitk
 {
 
 ImageStatisticsCalculator::ImageStatisticsCalculator()
 : m_MaskingMode( MASKING_MODE_NONE ),
   m_MaskingModeChanged( false ),
   m_IgnorePixelValue(0.0),
   m_DoIgnorePixelValue(false),
   m_IgnorePixelValueChanged(false),
   m_PlanarFigureAxis (0),
   m_PlanarFigureSlice (0),
   m_PlanarFigureCoordinate0 (0),
   m_PlanarFigureCoordinate1 (0)
 {
   m_EmptyHistogram = HistogramType::New();
   m_EmptyHistogram->SetMeasurementVectorSize(1);
   HistogramType::SizeType histogramSize(1);
   histogramSize.Fill( 256 );
   m_EmptyHistogram->Initialize( histogramSize );
 
   m_EmptyStatistics.Reset();
 }
 
 
 ImageStatisticsCalculator::~ImageStatisticsCalculator()
 {
 }
 
 
 void ImageStatisticsCalculator::SetImage( const mitk::Image *image )
 {
   if ( m_Image != image )
   {
     m_Image = image;
     this->Modified();
 
     unsigned int numberOfTimeSteps = image->GetTimeSteps();
 
     // Initialize vectors to time-size of this image
     m_ImageHistogramVector.resize( numberOfTimeSteps );
     m_MaskedImageHistogramVector.resize( numberOfTimeSteps );
     m_PlanarFigureHistogramVector.resize( numberOfTimeSteps );
 
     m_ImageStatisticsVector.resize( numberOfTimeSteps );
     m_MaskedImageStatisticsVector.resize( numberOfTimeSteps );
     m_PlanarFigureStatisticsVector.resize( numberOfTimeSteps );
 
     m_ImageStatisticsTimeStampVector.resize( numberOfTimeSteps );
     m_MaskedImageStatisticsTimeStampVector.resize( numberOfTimeSteps );
     m_PlanarFigureStatisticsTimeStampVector.resize( numberOfTimeSteps );
 
     m_ImageStatisticsCalculationTriggerVector.resize( numberOfTimeSteps );
     m_MaskedImageStatisticsCalculationTriggerVector.resize( numberOfTimeSteps );
     m_PlanarFigureStatisticsCalculationTriggerVector.resize( numberOfTimeSteps );
 
     for ( unsigned int t = 0; t < image->GetTimeSteps(); ++t )
     {
       m_ImageStatisticsTimeStampVector[t].Modified();
       m_ImageStatisticsCalculationTriggerVector[t] = true;
     }
   }
 }
 
 
 void ImageStatisticsCalculator::SetImageMask( const mitk::Image *imageMask )
 {
   if ( m_Image.IsNull() )
   {
     itkExceptionMacro( << "Image needs to be set first!" );
   }
 
   if ( m_ImageMask != imageMask )
   {
     m_ImageMask = imageMask;
     this->Modified();
 
     for ( unsigned int t = 0; t < m_Image->GetTimeSteps(); ++t )
     {
       m_MaskedImageStatisticsTimeStampVector[t].Modified();
       m_MaskedImageStatisticsCalculationTriggerVector[t] = true;
     }
   }
 }
 
 
 void ImageStatisticsCalculator::SetPlanarFigure( mitk::PlanarFigure *planarFigure )
 {
   if ( m_Image.IsNull() )
   {
     itkExceptionMacro( << "Image needs to be set first!" );
   }
 
   if ( m_PlanarFigure != planarFigure )
   {
     m_PlanarFigure = planarFigure;
     this->Modified();
 
     for ( unsigned int t = 0; t < m_Image->GetTimeSteps(); ++t )
     {
       m_PlanarFigureStatisticsTimeStampVector[t].Modified();
       m_PlanarFigureStatisticsCalculationTriggerVector[t] = true;
     }
   }
 }
 
 
 void ImageStatisticsCalculator::SetMaskingMode( unsigned int mode )
 {
   if ( m_MaskingMode != mode )
   {
     m_MaskingMode = mode;
     m_MaskingModeChanged = true;
     this->Modified();
   }
 }
 
 
 void ImageStatisticsCalculator::SetMaskingModeToNone()
 {
   if ( m_MaskingMode != MASKING_MODE_NONE )
   {
     m_MaskingMode = MASKING_MODE_NONE;
     m_MaskingModeChanged = true;
     this->Modified();
   }
 }
 
 
 void ImageStatisticsCalculator::SetMaskingModeToImage()
 {
   if ( m_MaskingMode != MASKING_MODE_IMAGE )
   {
     m_MaskingMode = MASKING_MODE_IMAGE;
     m_MaskingModeChanged = true;
     this->Modified();
   }
 }
 
 
 void ImageStatisticsCalculator::SetMaskingModeToPlanarFigure()
 {
   if ( m_MaskingMode != MASKING_MODE_PLANARFIGURE )
   {
     m_MaskingMode = MASKING_MODE_PLANARFIGURE;
     m_MaskingModeChanged = true;
     this->Modified();
   }
 }
 
 void ImageStatisticsCalculator::SetIgnorePixelValue(double value)
 {
   if ( m_IgnorePixelValue != value )
   {
     m_IgnorePixelValue = value;
     if(m_DoIgnorePixelValue)
     {
       m_IgnorePixelValueChanged = true;
     }
     this->Modified();
   }
 }
 
 double ImageStatisticsCalculator::GetIgnorePixelValue()
 {
   return m_IgnorePixelValue;
 }
 
 void ImageStatisticsCalculator::SetDoIgnorePixelValue(bool value)
 {
   if ( m_DoIgnorePixelValue != value )
   {
     m_DoIgnorePixelValue = value;
     m_IgnorePixelValueChanged = true;
     this->Modified();
   }
 }
 
 bool ImageStatisticsCalculator::GetDoIgnorePixelValue()
 {
   return m_DoIgnorePixelValue;
 }
 
 bool ImageStatisticsCalculator::ComputeStatistics( unsigned int timeStep )
 {
 
   if (m_Image.IsNull() )
   {
     mitkThrow() << "Image not set!";
   }
 
   if (!m_Image->IsInitialized())
   {
     mitkThrow() << "Image not initialized!";
   }
 
   if ( m_Image->GetReferenceCount() == 1 )
   {
     // Image no longer valid; we are the only ones to still hold a reference on it
     return false;
   }
 
   if ( timeStep >= m_Image->GetTimeSteps() )
   {
     throw std::runtime_error( "Error: invalid time step!" );
   }
 
   // If a mask was set but we are the only ones to still hold a reference on
   // it, delete it.
   if ( m_ImageMask.IsNotNull() && (m_ImageMask->GetReferenceCount() == 1) )
   {
     m_ImageMask = NULL;
   }
 
 
   // Check if statistics is already up-to-date
   unsigned long imageMTime = m_ImageStatisticsTimeStampVector[timeStep].GetMTime();
   unsigned long maskedImageMTime = m_MaskedImageStatisticsTimeStampVector[timeStep].GetMTime();
   unsigned long planarFigureMTime = m_PlanarFigureStatisticsTimeStampVector[timeStep].GetMTime();
 
   bool imageStatisticsCalculationTrigger = m_ImageStatisticsCalculationTriggerVector[timeStep];
   bool maskedImageStatisticsCalculationTrigger = m_MaskedImageStatisticsCalculationTriggerVector[timeStep];
   bool planarFigureStatisticsCalculationTrigger = m_PlanarFigureStatisticsCalculationTriggerVector[timeStep];
 
   if ( !m_IgnorePixelValueChanged
     && ((m_MaskingMode != MASKING_MODE_NONE) || (imageMTime > m_Image->GetMTime() && !imageStatisticsCalculationTrigger))
     && ((m_MaskingMode != MASKING_MODE_IMAGE) || (maskedImageMTime > m_ImageMask->GetMTime() && !maskedImageStatisticsCalculationTrigger))
     && ((m_MaskingMode != MASKING_MODE_PLANARFIGURE) || (planarFigureMTime > m_PlanarFigure->GetMTime() && !planarFigureStatisticsCalculationTrigger)) )
   {
     // Statistics is up to date!
     if ( m_MaskingModeChanged )
     {
       m_MaskingModeChanged = false;
       return true;
     }
     else
     {
       return false;
     }
   }
 
   // Reset state changed flag
   m_MaskingModeChanged = false;
   m_IgnorePixelValueChanged = false;
 
   // Depending on masking mode, extract and/or generate the required image
   // and mask data from the user input
   this->ExtractImageAndMask( timeStep );
 
 
   StatisticsContainer *statisticsContainer;
   HistogramContainer *histogramContainer;
   switch ( m_MaskingMode )
   {
   case MASKING_MODE_NONE:
   default:
     if(!m_DoIgnorePixelValue)
     {
       statisticsContainer = &m_ImageStatisticsVector[timeStep];
       histogramContainer = &m_ImageHistogramVector[timeStep];
 
       m_ImageStatisticsTimeStampVector[timeStep].Modified();
       m_ImageStatisticsCalculationTriggerVector[timeStep] = false;
     }
     else
     {
       statisticsContainer = &m_MaskedImageStatisticsVector[timeStep];
       histogramContainer = &m_MaskedImageHistogramVector[timeStep];
 
       m_MaskedImageStatisticsTimeStampVector[timeStep].Modified();
       m_MaskedImageStatisticsCalculationTriggerVector[timeStep] = false;
     }
     break;
 
   case MASKING_MODE_IMAGE:
     statisticsContainer = &m_MaskedImageStatisticsVector[timeStep];
     histogramContainer = &m_MaskedImageHistogramVector[timeStep];
 
     m_MaskedImageStatisticsTimeStampVector[timeStep].Modified();
     m_MaskedImageStatisticsCalculationTriggerVector[timeStep] = false;
     break;
 
   case MASKING_MODE_PLANARFIGURE:
     statisticsContainer = &m_PlanarFigureStatisticsVector[timeStep];
     histogramContainer = &m_PlanarFigureHistogramVector[timeStep];
 
     m_PlanarFigureStatisticsTimeStampVector[timeStep].Modified();
     m_PlanarFigureStatisticsCalculationTriggerVector[timeStep] = false;
     break;
   }
 
   // Calculate statistics and histogram(s)
   if ( m_InternalImage->GetDimension() == 3 )
   {
     if ( m_MaskingMode == MASKING_MODE_NONE && !m_DoIgnorePixelValue )
     {
       AccessFixedDimensionByItk_2(
         m_InternalImage,
         InternalCalculateStatisticsUnmasked,
         3,
         statisticsContainer,
         histogramContainer );
     }
     else
     {
       AccessFixedDimensionByItk_3(
         m_InternalImage,
         InternalCalculateStatisticsMasked,
         3,
         m_InternalImageMask3D.GetPointer(),
         statisticsContainer,
         histogramContainer );
     }
   }
   else if ( m_InternalImage->GetDimension() == 2 )
   {
     if ( m_MaskingMode == MASKING_MODE_NONE && !m_DoIgnorePixelValue )
     {
       AccessFixedDimensionByItk_2(
         m_InternalImage,
         InternalCalculateStatisticsUnmasked,
         2,
         statisticsContainer,
         histogramContainer );
     }
     else
     {
       AccessFixedDimensionByItk_3(
         m_InternalImage,
         InternalCalculateStatisticsMasked,
         2,
         m_InternalImageMask2D.GetPointer(),
         statisticsContainer,
         histogramContainer );
     }
   }
   else
   {
     MITK_ERROR << "ImageStatistics: Image dimension not supported!";
   }
 
 
   // Release unused image smart pointers to free memory
   m_InternalImage = mitk::Image::ConstPointer();
   m_InternalImageMask3D = MaskImage3DType::Pointer();
   m_InternalImageMask2D = MaskImage2DType::Pointer();
   return true;
 }
 
 
 const ImageStatisticsCalculator::HistogramType *
 ImageStatisticsCalculator::GetHistogram( unsigned int timeStep, unsigned int label ) const
 {
   if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
   {
     return NULL;
   }
 
   switch ( m_MaskingMode )
   {
   case MASKING_MODE_NONE:
   default:
     {
       if(m_DoIgnorePixelValue)
         return m_MaskedImageHistogramVector[timeStep][label];
 
       return m_ImageHistogramVector[timeStep][label];
     }
 
   case MASKING_MODE_IMAGE:
     return m_MaskedImageHistogramVector[timeStep][label];
 
   case MASKING_MODE_PLANARFIGURE:
     return m_PlanarFigureHistogramVector[timeStep][label];
   }
 }
 
 const ImageStatisticsCalculator::HistogramContainer &
 ImageStatisticsCalculator::GetHistogramVector( unsigned int timeStep ) const
 {
   if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
   {
     return m_EmptyHistogramContainer;
   }
 
   switch ( m_MaskingMode )
   {
   case MASKING_MODE_NONE:
   default:
     {
       if(m_DoIgnorePixelValue)
         return m_MaskedImageHistogramVector[timeStep];
 
       return m_ImageHistogramVector[timeStep];
     }
 
   case MASKING_MODE_IMAGE:
     return m_MaskedImageHistogramVector[timeStep];
 
   case MASKING_MODE_PLANARFIGURE:
     return m_PlanarFigureHistogramVector[timeStep];
   }
 }
 
 
 const ImageStatisticsCalculator::Statistics &
 ImageStatisticsCalculator::GetStatistics( unsigned int timeStep, unsigned int label ) const
 {
   if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
   {
     return m_EmptyStatistics;
   }
 
   switch ( m_MaskingMode )
   {
   case MASKING_MODE_NONE:
   default:
     {
       if(m_DoIgnorePixelValue)
         return m_MaskedImageStatisticsVector[timeStep][label];
 
       return m_ImageStatisticsVector[timeStep][label];
     }
   case MASKING_MODE_IMAGE:
     return m_MaskedImageStatisticsVector[timeStep][label];
 
   case MASKING_MODE_PLANARFIGURE:
     return m_PlanarFigureStatisticsVector[timeStep][label];
   }
 }
 
 
 const ImageStatisticsCalculator::StatisticsContainer &
 ImageStatisticsCalculator::GetStatisticsVector( unsigned int timeStep ) const
 {
   if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
   {
     return m_EmptyStatisticsContainer;
   }
 
   switch ( m_MaskingMode )
   {
   case MASKING_MODE_NONE:
   default:
     {
       if(m_DoIgnorePixelValue)
         return m_MaskedImageStatisticsVector[timeStep];
 
       return m_ImageStatisticsVector[timeStep];
     }
   case MASKING_MODE_IMAGE:
     return m_MaskedImageStatisticsVector[timeStep];
 
   case MASKING_MODE_PLANARFIGURE:
     return m_PlanarFigureStatisticsVector[timeStep];
   }
 }
 
 
 
 void ImageStatisticsCalculator::ExtractImageAndMask( unsigned int timeStep )
 {
   if ( m_Image.IsNull() )
   {
     throw std::runtime_error( "Error: image empty!" );
   }
 
   if ( timeStep >= m_Image->GetTimeSteps() )
   {
     throw std::runtime_error( "Error: invalid time step!" );
   }
 
   ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
   imageTimeSelector->SetInput( m_Image );
   imageTimeSelector->SetTimeNr( timeStep );
   imageTimeSelector->UpdateLargestPossibleRegion();
   mitk::Image *timeSliceImage = imageTimeSelector->GetOutput();
 
 
   switch ( m_MaskingMode )
   {
   case MASKING_MODE_NONE:
     {
       m_InternalImage = timeSliceImage;
       m_InternalImageMask2D = NULL;
       m_InternalImageMask3D = NULL;
 
       if(m_DoIgnorePixelValue)
       {
         if( m_InternalImage->GetDimension() == 3 )
         {
           CastToItkImage( timeSliceImage, m_InternalImageMask3D );
           m_InternalImageMask3D->FillBuffer(1);
         }
         if( m_InternalImage->GetDimension() == 2 )
         {
           CastToItkImage( timeSliceImage, m_InternalImageMask2D );
           m_InternalImageMask2D->FillBuffer(1);
         }
       }
       break;
     }
 
   case MASKING_MODE_IMAGE:
     {
       if ( m_ImageMask.IsNotNull() && (m_ImageMask->GetReferenceCount() > 1) )
       {
         if ( timeStep >= m_ImageMask->GetTimeSteps() )
         {
           // Use the last mask time step in case the current time step is bigger than the total
           // number of mask time steps.
           // It makes more sense setting this to the last mask time step than to 0.
           // For instance if you have a mask with 2 time steps and an image with 5:
           // If time step 0 is selected, the mask will use time step 0.
           // If time step 1 is selected, the mask will use time step 1.
           // If time step 2+ is selected, the mask will use time step 1.
           // If you have a mask with only one time step instead, this will always default to 0.
           timeStep = m_ImageMask->GetTimeSteps() - 1;
         }
 
         ImageTimeSelector::Pointer maskedImageTimeSelector = ImageTimeSelector::New();
         maskedImageTimeSelector->SetInput( m_ImageMask );
         maskedImageTimeSelector->SetTimeNr( timeStep );
         maskedImageTimeSelector->UpdateLargestPossibleRegion();
         mitk::Image *timeSliceMaskedImage = maskedImageTimeSelector->GetOutput();
 
         m_InternalImage = timeSliceImage;
         CastToItkImage( timeSliceMaskedImage, m_InternalImageMask3D );
       }
       else
       {
         throw std::runtime_error( "Error: image mask empty!" );
       }
       break;
     }
 
   case MASKING_MODE_PLANARFIGURE:
     {
       m_InternalImageMask2D = NULL;
 
       if ( m_PlanarFigure.IsNull() )
       {
         throw std::runtime_error( "Error: planar figure empty!" );
       }
       if ( !m_PlanarFigure->IsClosed() )
       {
         throw std::runtime_error( "Masking not possible for non-closed figures" );
       }
 
       const BaseGeometry *imageGeometry = timeSliceImage->GetGeometry();
       if ( imageGeometry == NULL )
       {
         throw std::runtime_error( "Image geometry invalid!" );
       }
 
-      const PlaneGeometry *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
-      if ( planarFigureGeometry2D == NULL )
+      const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
+      if ( planarFigurePlaneGeometry == NULL )
       {
         throw std::runtime_error( "Planar-Figure not yet initialized!" );
       }
 
       const PlaneGeometry *planarFigureGeometry =
-        dynamic_cast< const PlaneGeometry * >( planarFigureGeometry2D );
+        dynamic_cast< const PlaneGeometry * >( planarFigurePlaneGeometry );
       if ( planarFigureGeometry == NULL )
       {
         throw std::runtime_error( "Non-planar planar figures not supported!" );
       }
 
       // Find principal direction of PlanarFigure in input image
       unsigned int axis;
       if ( !this->GetPrincipalAxis( imageGeometry,
         planarFigureGeometry->GetNormal(), axis ) )
       {
         throw std::runtime_error( "Non-aligned planar figures not supported!" );
       }
       m_PlanarFigureAxis = axis;
 
 
       // Find slice number corresponding to PlanarFigure in input image
       MaskImage3DType::IndexType index;
       imageGeometry->WorldToIndex( planarFigureGeometry->GetOrigin(), index );
 
       unsigned int slice = index[axis];
       m_PlanarFigureSlice = slice;
 
 
       // Extract slice with given position and direction from image
       unsigned int dimension = timeSliceImage->GetDimension();
 
       if (dimension != 2)
       {
         ExtractImageFilter::Pointer imageExtractor = ExtractImageFilter::New();
         imageExtractor->SetInput( timeSliceImage );
         imageExtractor->SetSliceDimension( axis );
         imageExtractor->SetSliceIndex( slice );
         imageExtractor->Update();
         m_InternalImage = imageExtractor->GetOutput();
       }
       else
       {
         m_InternalImage = timeSliceImage;
       }
 
       // Compute mask from PlanarFigure
       AccessFixedDimensionByItk_1(
         m_InternalImage,
         InternalCalculateMaskFromPlanarFigure,
         2, axis );
     }
   }
 
   if(m_DoIgnorePixelValue)
   {
     if ( m_InternalImage->GetDimension() == 3 )
     {
       AccessFixedDimensionByItk_1(
           m_InternalImage,
           InternalMaskIgnoredPixels,
           3,
           m_InternalImageMask3D.GetPointer() );
     }
     else if ( m_InternalImage->GetDimension() == 2 )
     {
       AccessFixedDimensionByItk_1(
           m_InternalImage,
           InternalMaskIgnoredPixels,
           2,
           m_InternalImageMask2D.GetPointer() );
     }
   }
 }
 
 
 bool ImageStatisticsCalculator::GetPrincipalAxis(
   const BaseGeometry *geometry, Vector3D vector,
   unsigned int &axis )
 {
   vector.Normalize();
   for ( unsigned int i = 0; i < 3; ++i )
   {
     Vector3D axisVector = geometry->GetAxisVector( i );
     axisVector.Normalize();
 
     if ( fabs( fabs( axisVector * vector ) - 1.0) < mitk::eps )
     {
       axis = i;
       return true;
     }
   }
 
   return false;
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void ImageStatisticsCalculator::InternalCalculateStatisticsUnmasked(
   const itk::Image< TPixel, VImageDimension > *image,
   StatisticsContainer *statisticsContainer,
   HistogramContainer* histogramContainer )
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
   typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
   typedef typename ImageType::IndexType IndexType;
 
   typedef itk::Statistics::ScalarImageToHistogramGenerator< ImageType >
     HistogramGeneratorType;
 
   statisticsContainer->clear();
   histogramContainer->clear();
 
   // Progress listening...
   typedef itk::SimpleMemberCommand< ImageStatisticsCalculator > ITKCommandType;
   ITKCommandType::Pointer progressListener;
   progressListener = ITKCommandType::New();
   progressListener->SetCallbackFunction( this,
     &ImageStatisticsCalculator::UnmaskedStatisticsProgressUpdate );
 
 
   // Issue 100 artificial progress events since ScalarIMageToHistogramGenerator
   // does not (yet?) support progress reporting
   this->InvokeEvent( itk::StartEvent() );
   for ( unsigned int i = 0; i < 100; ++i )
   {
     this->UnmaskedStatisticsProgressUpdate();
   }
 
   // Calculate statistics (separate filter)
   typedef itk::StatisticsImageFilter< ImageType > StatisticsFilterType;
   typename StatisticsFilterType::Pointer statisticsFilter = StatisticsFilterType::New();
   statisticsFilter->SetInput( image );
   unsigned long observerTag = statisticsFilter->AddObserver( itk::ProgressEvent(), progressListener );
   statisticsFilter->Update();
   statisticsFilter->RemoveObserver( observerTag );
   this->InvokeEvent( itk::EndEvent() );
 
   // Calculate minimum and maximum
   typedef itk::MinimumMaximumImageCalculator< ImageType > MinMaxFilterType;
   typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
   minMaxFilter->SetImage( image );
   unsigned long observerTag2 = minMaxFilter->AddObserver( itk::ProgressEvent(), progressListener );
   minMaxFilter->Compute();
   minMaxFilter->RemoveObserver( observerTag2 );
   this->InvokeEvent( itk::EndEvent() );
 
   Statistics statistics; statistics.Reset();
   statistics.Label = 1;
   statistics.N = image->GetBufferedRegion().GetNumberOfPixels();
   statistics.Min = statisticsFilter->GetMinimum();
   statistics.Max = statisticsFilter->GetMaximum();
   statistics.Mean = statisticsFilter->GetMean();
   statistics.Median = 0.0;
   statistics.Sigma = statisticsFilter->GetSigma();
   statistics.RMS = sqrt( statistics.Mean * statistics.Mean + statistics.Sigma * statistics.Sigma );
 
   statistics.MinIndex.set_size(image->GetImageDimension());
   statistics.MaxIndex.set_size(image->GetImageDimension());
   for (unsigned int i=0; i<statistics.MaxIndex.size(); i++)
   {
       statistics.MaxIndex[i] = minMaxFilter->GetIndexOfMaximum()[i];
       statistics.MinIndex[i] = minMaxFilter->GetIndexOfMinimum()[i];
   }
 
   statisticsContainer->push_back( statistics );
 
    // Calculate histogram
   typename HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
   histogramGenerator->SetInput( image );
   histogramGenerator->SetMarginalScale( 100 );
   histogramGenerator->SetNumberOfBins( 768 );
   histogramGenerator->SetHistogramMin( statistics.Min );
   histogramGenerator->SetHistogramMax( statistics.Max );
   histogramGenerator->Compute();
 
   histogramContainer->push_back( histogramGenerator->GetOutput() );
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void ImageStatisticsCalculator::InternalMaskIgnoredPixels(
   const itk::Image< TPixel, VImageDimension > *image,
   itk::Image< unsigned short, VImageDimension > *maskImage )
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
   typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
 
   itk::ImageRegionIterator<MaskImageType>
       itmask(maskImage, maskImage->GetLargestPossibleRegion());
   itk::ImageRegionConstIterator<ImageType>
       itimage(image, image->GetLargestPossibleRegion());
 
   itmask.GoToBegin();
   itimage.GoToBegin();
 
   while( !itmask.IsAtEnd() )
   {
     if(m_IgnorePixelValue == itimage.Get())
     {
       itmask.Set(0);
     }
 
     ++itmask;
     ++itimage;
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void ImageStatisticsCalculator::InternalCalculateStatisticsMasked(
   const itk::Image< TPixel, VImageDimension > *image,
   itk::Image< unsigned short, VImageDimension > *maskImage,
   StatisticsContainer* statisticsContainer,
   HistogramContainer* histogramContainer )
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
   typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
 
   typedef typename ImageType::IndexType IndexType;
   typedef typename ImageType::PointType PointType;
   typedef typename ImageType::SpacingType SpacingType;
 
   typedef itk::LabelStatisticsImageFilter< ImageType, MaskImageType > LabelStatisticsFilterType;
 
   typedef itk::ChangeInformationImageFilter< MaskImageType > ChangeInformationFilterType;
 
   typedef itk::ExtractImageFilter< ImageType, ImageType > ExtractImageFilterType;
 
   statisticsContainer->clear();
   histogramContainer->clear();
 
 
   // Make sure that mask is set
   if ( maskImage == NULL  )
   {
     itkExceptionMacro( << "Mask image needs to be set!" );
   }
 
 
   // Make sure that spacing of mask and image are the same
   SpacingType imageSpacing = image->GetSpacing();
   SpacingType maskSpacing = maskImage->GetSpacing();
   PointType zeroPoint; zeroPoint.Fill( 0.0 );
   if ( (zeroPoint + imageSpacing).SquaredEuclideanDistanceTo( (zeroPoint + maskSpacing) ) > mitk::eps )
   {
     itkExceptionMacro( << "Mask needs to have same spacing as image! (Image spacing: " << imageSpacing << "; Mask spacing: " << maskSpacing << ")" );
   }
 
   // Make sure that orientation of mask and image are the same
   typedef typename ImageType::DirectionType DirectionType;
   DirectionType imageDirection = image->GetDirection();
   DirectionType maskDirection = maskImage->GetDirection();
   for( int i = 0; i < imageDirection.ColumnDimensions; ++i )
   {
     for( int j = 0; j < imageDirection.ColumnDimensions; ++j )
     {
       double differenceDirection = imageDirection[i][j] - maskDirection[i][j];
       if ( fabs( differenceDirection ) > mitk::eps )
       {
         itkExceptionMacro( << "Mask needs to have same direction as image! (Image direction: " << imageDirection << "; Mask direction: " << maskDirection << ")" );
       }
     }
   }
 
   // Make sure that the voxels of mask and image are correctly "aligned", i.e., voxel boundaries are the same in both images
   PointType imageOrigin = image->GetOrigin();
   PointType maskOrigin = maskImage->GetOrigin();
   long offset[ImageType::ImageDimension];
 
   typedef itk::ContinuousIndex<double, VImageDimension> ContinousIndexType;
   ContinousIndexType maskOriginContinousIndex, imageOriginContinousIndex;
 
   image->TransformPhysicalPointToContinuousIndex(maskOrigin, maskOriginContinousIndex);
   image->TransformPhysicalPointToContinuousIndex(imageOrigin, imageOriginContinousIndex);
 
   for ( unsigned int i = 0; i < ImageType::ImageDimension; ++i )
   {
     double misalignment = maskOriginContinousIndex[i] - floor( maskOriginContinousIndex[i] + 0.5 );
     if ( fabs( misalignment ) > mitk::eps )
     {
       itkExceptionMacro( << "Pixels/voxels of mask and image are not sufficiently aligned! (Misalignment: " << misalignment << ")" );
     }
 
     double indexCoordDistance = maskOriginContinousIndex[i] - imageOriginContinousIndex[i];
     offset[i] = (int) indexCoordDistance + image->GetBufferedRegion().GetIndex()[i];
   }
 
   // Adapt the origin and region (index/size) of the mask so that the origin of both are the same
   typename ChangeInformationFilterType::Pointer adaptMaskFilter;
   adaptMaskFilter = ChangeInformationFilterType::New();
   adaptMaskFilter->ChangeOriginOn();
   adaptMaskFilter->ChangeRegionOn();
   adaptMaskFilter->SetInput( maskImage );
   adaptMaskFilter->SetOutputOrigin( image->GetOrigin() );
   adaptMaskFilter->SetOutputOffset( offset );
   adaptMaskFilter->Update();
   typename MaskImageType::Pointer adaptedMaskImage = adaptMaskFilter->GetOutput();
 
 
   // Make sure that mask region is contained within image region
   if ( !image->GetLargestPossibleRegion().IsInside( adaptedMaskImage->GetLargestPossibleRegion() ) )
   {
     itkExceptionMacro( << "Mask region needs to be inside of image region! (Image region: "
       << image->GetLargestPossibleRegion() << "; Mask region: " << adaptedMaskImage->GetLargestPossibleRegion() << ")" );
   }
 
 
   // If mask region is smaller than image region, extract the sub-sampled region from the original image
   typename ImageType::SizeType imageSize = image->GetBufferedRegion().GetSize();
   typename ImageType::SizeType maskSize = maskImage->GetBufferedRegion().GetSize();
   bool maskSmallerImage = false;
   for ( unsigned int i = 0; i < ImageType::ImageDimension; ++i )
   {
     if ( maskSize[i] < imageSize[i] )
     {
       maskSmallerImage = true;
     }
   }
 
   typename ImageType::ConstPointer adaptedImage;
   if ( maskSmallerImage )
   {
     typename ExtractImageFilterType::Pointer extractImageFilter = ExtractImageFilterType::New();
     extractImageFilter->SetInput( image );
     extractImageFilter->SetExtractionRegion( adaptedMaskImage->GetBufferedRegion() );
     extractImageFilter->Update();
     adaptedImage = extractImageFilter->GetOutput();
   }
   else
   {
     adaptedImage = image;
   }
 
   // Initialize Filter
   typedef itk::StatisticsImageFilter< ImageType > StatisticsFilterType;
   typename StatisticsFilterType::Pointer statisticsFilter = StatisticsFilterType::New();
   statisticsFilter->SetInput( adaptedImage );
 
   statisticsFilter->Update();
 
   int numberOfBins = ( m_DoIgnorePixelValue && (m_MaskingMode == MASKING_MODE_NONE) ) ? 768 : 384;
   typename LabelStatisticsFilterType::Pointer labelStatisticsFilter;
   labelStatisticsFilter = LabelStatisticsFilterType::New();
   labelStatisticsFilter->SetInput( adaptedImage );
   labelStatisticsFilter->SetLabelInput( adaptedMaskImage );
   labelStatisticsFilter->UseHistogramsOn();
   labelStatisticsFilter->SetHistogramParameters( numberOfBins, statisticsFilter->GetMinimum(), statisticsFilter->GetMaximum() );
 
 
   // Add progress listening
   typedef itk::SimpleMemberCommand< ImageStatisticsCalculator > ITKCommandType;
   ITKCommandType::Pointer progressListener;
   progressListener = ITKCommandType::New();
   progressListener->SetCallbackFunction( this,
     &ImageStatisticsCalculator::MaskedStatisticsProgressUpdate );
   unsigned long observerTag = labelStatisticsFilter->AddObserver(
     itk::ProgressEvent(), progressListener );
 
   // Execute filter
   this->InvokeEvent( itk::StartEvent() );
 
   // Make sure that only the mask region is considered (otherwise, if the mask region is smaller
   // than the image region, the Update() would result in an exception).
   labelStatisticsFilter->GetOutput()->SetRequestedRegion( adaptedMaskImage->GetLargestPossibleRegion() );
 
 
   // Execute the filter
   labelStatisticsFilter->Update();
   this->InvokeEvent( itk::EndEvent() );
   labelStatisticsFilter->RemoveObserver( observerTag );
 
   // Find all relevant labels of mask (other than 0)
   std::list< int > relevantLabels;
   bool maskNonEmpty = false;
   unsigned int i;
   for ( i = 1; i < 4096; ++i )
   {
     if ( labelStatisticsFilter->HasLabel( i ) )
     {
       relevantLabels.push_back( i );
       maskNonEmpty = true;
     }
   }
   if ( maskNonEmpty )
   {
     std::list< int >::iterator it;
     for ( it = relevantLabels.begin(), i = 0;
           it != relevantLabels.end();
           ++it, ++i )
     {
       histogramContainer->push_back( HistogramType::ConstPointer( labelStatisticsFilter->GetHistogram( (*it) ) ) );
 
       Statistics statistics;
       statistics.Label = (*it);
       statistics.N = labelStatisticsFilter->GetCount( *it );
       statistics.Min = labelStatisticsFilter->GetMinimum( *it );
       statistics.Max = labelStatisticsFilter->GetMaximum( *it );
       statistics.Mean = labelStatisticsFilter->GetMean( *it );
       statistics.Median = labelStatisticsFilter->GetMedian( *it );
       statistics.Sigma = labelStatisticsFilter->GetSigma( *it );
       statistics.RMS = sqrt( statistics.Mean * statistics.Mean
         + statistics.Sigma * statistics.Sigma );
 
       // restrict image to mask area for min/max index calculation
       typedef itk::MaskImageFilter< ImageType, MaskImageType, ImageType > MaskImageFilterType;
       typename MaskImageFilterType::Pointer masker = MaskImageFilterType::New();
       masker->SetOutsideValue( (statistics.Min+statistics.Max)/2 );
       masker->SetInput1(adaptedImage);
       masker->SetInput2(adaptedMaskImage);
       masker->Update();
       // get index of minimum and maximum
       typedef itk::MinimumMaximumImageCalculator< ImageType > MinMaxFilterType;
       typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
       minMaxFilter->SetImage( masker->GetOutput() );
       unsigned long observerTag2 = minMaxFilter->AddObserver( itk::ProgressEvent(), progressListener );
       minMaxFilter->Compute();
       minMaxFilter->RemoveObserver( observerTag2 );
       this->InvokeEvent( itk::EndEvent() );
 
         statistics.MinIndex.set_size(adaptedImage->GetImageDimension());
         statistics.MaxIndex.set_size(adaptedImage->GetImageDimension());
 
         typename MinMaxFilterType::IndexType tempMaxIndex = minMaxFilter->GetIndexOfMaximum();
         typename MinMaxFilterType::IndexType tempMinIndex = minMaxFilter->GetIndexOfMinimum();
 
 // FIX BUG 14644
         //If a PlanarFigure is used for segmentation the
         //adaptedImage is a single slice (2D). Adding the
         // 3. dimension.
         if (m_MaskingMode == MASKING_MODE_PLANARFIGURE && m_Image->GetDimension()==3)
         {
             statistics.MaxIndex.set_size(m_Image->GetDimension());
             statistics.MaxIndex[m_PlanarFigureCoordinate0]=tempMaxIndex[0];
             statistics.MaxIndex[m_PlanarFigureCoordinate1]=tempMaxIndex[1];
             statistics.MaxIndex[m_PlanarFigureAxis]=m_PlanarFigureSlice;
 
             statistics.MinIndex.set_size(m_Image->GetDimension());
             statistics.MinIndex[m_PlanarFigureCoordinate0]=tempMinIndex[0];
             statistics.MinIndex[m_PlanarFigureCoordinate1]=tempMinIndex[1];
             statistics.MinIndex[m_PlanarFigureAxis]=m_PlanarFigureSlice;
         } else
         {
           for (unsigned int i = 0; i<statistics.MaxIndex.size(); i++)
           {
             statistics.MaxIndex[i] = tempMaxIndex[i];
             statistics.MinIndex[i] = tempMinIndex[i];
           }
         }
 // FIX END
 
       statisticsContainer->push_back( statistics );
     }
   }
   else
   {
     histogramContainer->push_back( HistogramType::ConstPointer( m_EmptyHistogram ) );
     statisticsContainer->push_back( Statistics() );
   }
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void ImageStatisticsCalculator::InternalCalculateMaskFromPlanarFigure(
   const itk::Image< TPixel, VImageDimension > *image, unsigned int axis )
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
 
   typedef itk::CastImageFilter< ImageType, MaskImage2DType > CastFilterType;
 
   // Generate mask image as new image with same header as input image and
   // initialize with "1".
   typename CastFilterType::Pointer castFilter = CastFilterType::New();
   castFilter->SetInput( image );
   castFilter->Update();
   castFilter->GetOutput()->FillBuffer( 1 );
 
   // all PolylinePoints of the PlanarFigure are stored in a vtkPoints object.
   // These points are used by the vtkLassoStencilSource to create
   // a vtkImageStencil.
-  const mitk::PlaneGeometry *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
+  const mitk::PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
   const typename PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
   const mitk::BaseGeometry *imageGeometry3D = m_Image->GetGeometry( 0 );
   // If there is a second poly line in a closed planar figure, treat it as a hole.
   PlanarFigure::PolyLineType planarFigureHolePolyline;
 
   if (m_PlanarFigure->GetPolyLinesSize() == 2)
     planarFigureHolePolyline = m_PlanarFigure->GetPolyLine(1);
 
 
   // Determine x- and y-dimensions depending on principal axis
   int i0, i1;
   switch ( axis )
   {
     case 0:
       i0 = 1;
       i1 = 2;
       break;
 
     case 1:
       i0 = 0;
       i1 = 2;
       break;
 
     case 2:
     default:
       i0 = 0;
       i1 = 1;
       break;
   }
   m_PlanarFigureCoordinate0= i0;
   m_PlanarFigureCoordinate1= i1;
 
   // store the polyline contour as vtkPoints object
   bool outOfBounds = false;
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   typename PlanarFigure::PolyLineType::const_iterator it;
   for ( it = planarFigurePolyline.begin();
         it != planarFigurePolyline.end();
         ++it )
   {
     Point3D point3D;
 
     // Convert 2D point back to the local index coordinates of the selected
     // image
-    planarFigureGeometry2D->Map( it->Point, point3D );
+    planarFigurePlaneGeometry->Map( it->Point, point3D );
 
     // Polygons (partially) outside of the image bounds can not be processed
     // further due to a bug in vtkPolyDataToImageStencil
     if ( !imageGeometry3D->IsInside( point3D ) )
     {
       outOfBounds = true;
     }
 
     imageGeometry3D->WorldToIndex( point3D, point3D );
 
     points->InsertNextPoint( point3D[i0], point3D[i1], 0 );
   }
 
   vtkSmartPointer<vtkPoints> holePoints = NULL;
 
   if (!planarFigureHolePolyline.empty())
   {
     holePoints = vtkSmartPointer<vtkPoints>::New();
 
     Point3D point3D;
     PlanarFigure::PolyLineType::const_iterator end = planarFigureHolePolyline.end();
 
     for (it = planarFigureHolePolyline.begin(); it != end; ++it)
     {
-      planarFigureGeometry2D->Map(it->Point, point3D);
+      planarFigurePlaneGeometry->Map(it->Point, point3D);
       imageGeometry3D->WorldToIndex(point3D, point3D);
       holePoints->InsertNextPoint(point3D[i0], point3D[i1], 0);
     }
   }
 
   // mark a malformed 2D planar figure ( i.e. area = 0 ) as out of bounds
   // this can happen when all control points of a rectangle lie on the same line = two of the three extents are zero
   double bounds[6] = {0, 0, 0, 0, 0, 0};
   points->GetBounds( bounds );
   bool extent_x = (fabs(bounds[0] - bounds[1])) < mitk::eps;
   bool extent_y = (fabs(bounds[2] - bounds[3])) < mitk::eps;
   bool extent_z = (fabs(bounds[4] - bounds[5])) < mitk::eps;
 
   // throw an exception if a closed planar figure is deformed, i.e. has only one non-zero extent
   if ( m_PlanarFigure->IsClosed() &&
        ((extent_x && extent_y) || (extent_x && extent_z)  || (extent_y && extent_z)))
   {
     mitkThrow() << "Figure has a zero area and cannot be used for masking.";
   }
 
   if ( outOfBounds )
   {
     throw std::runtime_error( "Figure at least partially outside of image bounds!" );
   }
 
   // create a vtkLassoStencilSource and set the points of the Polygon
   vtkSmartPointer<vtkLassoStencilSource> lassoStencil = vtkSmartPointer<vtkLassoStencilSource>::New();
   lassoStencil->SetShapeToPolygon();
   lassoStencil->SetPoints( points );
 
   vtkSmartPointer<vtkLassoStencilSource> holeLassoStencil = NULL;
 
   if (holePoints.GetPointer() != NULL)
   {
     holeLassoStencil = vtkSmartPointer<vtkLassoStencilSource>::New();
     holeLassoStencil->SetShapeToPolygon();
     holeLassoStencil->SetPoints(holePoints);
   }
 
   // Export from ITK to VTK (to use a VTK filter)
   typedef itk::VTKImageImport< MaskImage2DType > ImageImportType;
   typedef itk::VTKImageExport< MaskImage2DType > ImageExportType;
 
   typename ImageExportType::Pointer itkExporter = ImageExportType::New();
   itkExporter->SetInput( castFilter->GetOutput() );
 
   vtkSmartPointer<vtkImageImport> vtkImporter = vtkSmartPointer<vtkImageImport>::New();
   this->ConnectPipelines( itkExporter, vtkImporter );
 
   // Apply the generated image stencil to the input image
   vtkSmartPointer<vtkImageStencil> imageStencilFilter = vtkSmartPointer<vtkImageStencil>::New();
   imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
   imageStencilFilter->SetStencilConnection(lassoStencil->GetOutputPort());
   imageStencilFilter->ReverseStencilOff();
   imageStencilFilter->SetBackgroundValue( 0 );
   imageStencilFilter->Update();
 
   vtkSmartPointer<vtkImageStencil> holeStencilFilter = NULL;
 
   if (holeLassoStencil.GetPointer() != NULL)
   {
     holeStencilFilter = vtkSmartPointer<vtkImageStencil>::New();
     holeStencilFilter->SetInputConnection(imageStencilFilter->GetOutputPort());
     holeStencilFilter->SetStencilConnection(holeLassoStencil->GetOutputPort());
     holeStencilFilter->ReverseStencilOn();
     holeStencilFilter->SetBackgroundValue(0);
     holeStencilFilter->Update();
   }
 
   // Export from VTK back to ITK
   vtkSmartPointer<vtkImageExport> vtkExporter = vtkSmartPointer<vtkImageExport>::New();
   vtkExporter->SetInputConnection( holeStencilFilter.GetPointer() == NULL
     ? imageStencilFilter->GetOutputPort()
     : holeStencilFilter->GetOutputPort());
   vtkExporter->Update();
 
   typename ImageImportType::Pointer itkImporter = ImageImportType::New();
   this->ConnectPipelines( vtkExporter, itkImporter );
   itkImporter->Update();
 
   typedef itk::ImageDuplicator< ImageImportType::OutputImageType > DuplicatorType;
   DuplicatorType::Pointer duplicator = DuplicatorType::New();
   duplicator->SetInputImage( itkImporter->GetOutput() );
   duplicator->Update();
 
   // Store mask
   m_InternalImageMask2D = duplicator->GetOutput();
 }
 
 
 void ImageStatisticsCalculator::UnmaskedStatisticsProgressUpdate()
 {
   // Need to throw away every second progress event to reach a final count of
   // 100 since two consecutive filters are used in this case
   static int updateCounter = 0;
   if ( updateCounter++ % 2 == 0 )
   {
     this->InvokeEvent( itk::ProgressEvent() );
   }
 }
 
 
 void ImageStatisticsCalculator::MaskedStatisticsProgressUpdate()
 {
   this->InvokeEvent( itk::ProgressEvent() );
 }
 
 
 }
diff --git a/Modules/ImageStatistics/mitkIntensityProfile.cpp b/Modules/ImageStatistics/mitkIntensityProfile.cpp
index de18b0b67a..590cf415db 100644
--- a/Modules/ImageStatistics/mitkIntensityProfile.cpp
+++ b/Modules/ImageStatistics/mitkIntensityProfile.cpp
@@ -1,337 +1,337 @@
 /*===================================================================
 
 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 <itkLinearInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkPolyLineParametricPath.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 #include "mitkIntensityProfile.h"
 
 using namespace mitk;
 
 template <class T>
 static void ReadPixel(const PixelType&, Image::Pointer image, const Index3D& index, ScalarType* returnValue)
 {
   switch (image->GetDimension())
   {
   case 2:
     {
       ImagePixelReadAccessor<T, 2> readAccess(image, image->GetSliceData(0));
       *returnValue = readAccess.GetPixelByIndex(reinterpret_cast<const itk::Index<2>&>(index));
       break;
     }
 
   case 3:
     {
       ImagePixelReadAccessor<T, 3> readAccess(image, image->GetVolumeData(0));
       *returnValue = readAccess.GetPixelByIndex(index);
       break;
     }
 
   default:
     *returnValue = 0;
     break;
   }
 }
 
 static IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, itk::PolyLineParametricPath<3>::Pointer path)
 {
   IntensityProfile::Pointer intensityProfile = IntensityProfile::New();
   itk::PolyLineParametricPath<3>::InputType input = path->StartOfInput();
   BaseGeometry* imageGeometry = image->GetGeometry();
   const PixelType pixelType = image->GetPixelType();
 
   IntensityProfile::MeasurementVectorType measurementVector;
   itk::PolyLineParametricPath<3>::OffsetType offset;
   Point3D worldPoint;
   Index3D index;
 
   do
   {
     imageGeometry->IndexToWorld(path->Evaluate(input), worldPoint);
     imageGeometry->WorldToIndex(worldPoint, index);
 
     mitkPixelTypeMultiplex3(ReadPixel, pixelType, image, index, measurementVector.GetDataPointer());
     intensityProfile->PushBack(measurementVector);
 
     offset = path->IncrementInput(input);
   } while ((offset[0] | offset[1] | offset[2]) != 0);
 
   return intensityProfile;
 }
 
 template <class TInputImage>
 static typename itk::InterpolateImageFunction<TInputImage>::Pointer CreateInterpolateImageFunction(InterpolateImageFunction::Enum interpolator)
 {
   switch (interpolator)
   {
   case InterpolateImageFunction::NearestNeighbor:
     return itk::NearestNeighborInterpolateImageFunction<TInputImage>::New().GetPointer();
 
   case InterpolateImageFunction::Linear:
     return itk::LinearInterpolateImageFunction<TInputImage>::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Blackman_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::BlackmanWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Blackman_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::BlackmanWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Blackman_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::BlackmanWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Cosine_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::CosineWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Cosine_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::CosineWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Cosine_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::CosineWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Hamming_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::HammingWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Hamming_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::HammingWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Hamming_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::HammingWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Lanczos_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::LanczosWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Lanczos_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::LanczosWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Lanczos_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::LanczosWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Welch_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::WelchWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Welch_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::WelchWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Welch_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::WelchWindowFunction<5> >::New().GetPointer();
 
   default:
     return itk::NearestNeighborInterpolateImageFunction<TInputImage>::New().GetPointer();
   }
 }
 
 template <class TPixel, unsigned int VImageDimension>
 static void ComputeIntensityProfile(itk::Image<TPixel, VImageDimension>* image, itk::PolyLineParametricPath<3>::Pointer path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator, IntensityProfile::Pointer intensityProfile)
 {
   typename itk::InterpolateImageFunction<itk::Image<TPixel, VImageDimension> >::Pointer interpolateImageFunction = CreateInterpolateImageFunction<itk::Image<TPixel, VImageDimension> >(interpolator);
   interpolateImageFunction->SetInputImage(image);
 
   const itk::PolyLineParametricPath<3>::InputType startOfInput = path->StartOfInput();
   const itk::PolyLineParametricPath<3>::InputType delta = 1.0 / (numSamples - 1);
 
   IntensityProfile::MeasurementVectorType measurementVector;
 
   for (unsigned int i = 0; i < numSamples; ++i)
   {
     measurementVector[0] = interpolateImageFunction->EvaluateAtContinuousIndex(path->Evaluate(startOfInput + i * delta));
     intensityProfile->PushBack(measurementVector);
   }
 }
 
 static IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, itk::PolyLineParametricPath<3>::Pointer path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
 {
   IntensityProfile::Pointer intensityProfile = IntensityProfile::New();
   AccessFixedDimensionByItk_n(image, ComputeIntensityProfile, 3, (path, numSamples, interpolator, intensityProfile));
   return intensityProfile;
 }
 
 class AddPolyLineElementToPath
 {
 public:
   AddPolyLineElementToPath(const PlaneGeometry* planarFigureGeometry, const BaseGeometry* imageGeometry, itk::PolyLineParametricPath<3>::Pointer path)
     : m_PlanarFigureGeometry(planarFigureGeometry),
       m_ImageGeometry(imageGeometry),
       m_Path(path)
   {
   }
 
   void operator()(const PlanarFigure::PolyLineElement& polyLineElement)
   {
     m_PlanarFigureGeometry->Map(polyLineElement.Point, m_WorldPoint);
     m_ImageGeometry->WorldToIndex(m_WorldPoint, m_ContinuousIndexPoint);
     m_Vertex.CastFrom(m_ContinuousIndexPoint);
     m_Path->AddVertex(m_Vertex);
   }
 
 private:
   const PlaneGeometry* m_PlanarFigureGeometry;
   const BaseGeometry* m_ImageGeometry;
   itk::PolyLineParametricPath<3>::Pointer m_Path;
 
   Point3D m_WorldPoint;
   Point3D m_ContinuousIndexPoint;
   itk::PolyLineParametricPath<3>::ContinuousIndexType m_Vertex;
 };
 
 static itk::PolyLineParametricPath<3>::Pointer CreatePathFromPlanarFigure(BaseGeometry* imageGeometry, PlanarFigure* planarFigure)
 {
   itk::PolyLineParametricPath<3>::Pointer path = itk::PolyLineParametricPath<3>::New();
   const PlanarFigure::PolyLineType polyLine = planarFigure->GetPolyLine(0);
 
   std::for_each(polyLine.begin(), polyLine.end(),
-    AddPolyLineElementToPath(planarFigure->GetGeometry2D(), imageGeometry, path));
+    AddPolyLineElementToPath(planarFigure->GetPlaneGeometry(), imageGeometry, path));
 
   return path;
 }
 
 static void AddPointToPath(const BaseGeometry* imageGeometry, const Point3D& point, itk::PolyLineParametricPath<3>::Pointer path)
 {
   Point3D continuousIndexPoint;
   imageGeometry->WorldToIndex(point, continuousIndexPoint);
 
   itk::PolyLineParametricPath<3>::ContinuousIndexType vertex;
   vertex.CastFrom(continuousIndexPoint);
 
   path->AddVertex(vertex);
 }
 
 static itk::PolyLineParametricPath<3>::Pointer CreatePathFromPoints(BaseGeometry* imageGeometry, const Point3D& startPoint, const Point3D& endPoint)
 {
   itk::PolyLineParametricPath<3>::Pointer path = itk::PolyLineParametricPath<3>::New();
 
   AddPointToPath(imageGeometry, startPoint, path);
   AddPointToPath(imageGeometry, endPoint, path);
 
   return path;
 }
 
 IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarFigure::Pointer planarFigure)
 {
   return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarFigure));
 }
 
 IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarLine::Pointer planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
 {
   return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarLine.GetPointer()), numSamples, interpolator);
 }
 
 IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, const Point3D& startPoint, const Point3D& endPoint, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
 {
   return ::ComputeIntensityProfile(image, CreatePathFromPoints(image->GetGeometry(), startPoint, endPoint), numSamples, interpolator);
 }
 
 IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMaximum(IntensityProfile::Pointer intensityProfile)
 {
   IntensityProfile::MeasurementType max = -vcl_numeric_limits<IntensityProfile::MeasurementType>::max();
   IntensityProfile::InstanceIdentifier maxIndex = 0;
 
   IntensityProfile::ConstIterator end = intensityProfile->End();
   IntensityProfile::MeasurementType measurement;
 
   for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
   {
     measurement = it.GetMeasurementVector()[0];
 
     if (measurement > max)
     {
       max = measurement;
       maxIndex = it.GetInstanceIdentifier();
     }
   }
 
   return maxIndex;
 }
 
 IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMinimum(IntensityProfile::Pointer intensityProfile)
 {
   IntensityProfile::MeasurementType min = vcl_numeric_limits<IntensityProfile::MeasurementType>::max();
   IntensityProfile::InstanceIdentifier minIndex = 0;
 
   IntensityProfile::ConstIterator end = intensityProfile->End();
   IntensityProfile::MeasurementType measurement;
 
   for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
   {
     measurement = it.GetMeasurementVector()[0];
 
     if (measurement < min)
     {
       min = measurement;
       minIndex = it.GetInstanceIdentifier();
     }
   }
 
   return minIndex;
 }
 
 IntensityProfile::InstanceIdentifier mitk::ComputeCenterOfMaximumArea(IntensityProfile::Pointer intensityProfile, IntensityProfile::InstanceIdentifier radius)
 {
   const IntensityProfile::MeasurementType min = intensityProfile->GetMeasurementVector(ComputeGlobalMinimum(intensityProfile))[0];
   const IntensityProfile::InstanceIdentifier areaWidth = 1 + 2 * radius;
 
   IntensityProfile::MeasurementType maxArea = 0;
 
   for (IntensityProfile::InstanceIdentifier i = 0; i < areaWidth; ++i)
     maxArea += intensityProfile->GetMeasurementVector(i)[0] - min;
 
   const IntensityProfile::InstanceIdentifier lastIndex = intensityProfile->Size() - areaWidth;
   IntensityProfile::InstanceIdentifier centerOfMaxArea = radius;
   IntensityProfile::MeasurementType area = maxArea;
 
   for (IntensityProfile::InstanceIdentifier i = 1; i <= lastIndex; ++i)
   {
     area += intensityProfile->GetMeasurementVector(i + areaWidth - 1)[0] - min;
     area -= intensityProfile->GetMeasurementVector(i - 1)[0] - min;
 
     if (area > maxArea)
     {
       maxArea = area;
       centerOfMaxArea = i + radius; // TODO: If multiple areas in the neighborhood have the same intensity chose the middle one instead of the first one.
     }
   }
 
   return centerOfMaxArea;
 }
 
 std::vector<IntensityProfile::MeasurementType> mitk::CreateVectorFromIntensityProfile(IntensityProfile::Pointer intensityProfile)
 {
   std::vector<IntensityProfile::MeasurementType> result;
   result.reserve(intensityProfile->Size());
 
   IntensityProfile::ConstIterator end = intensityProfile->End();
 
   for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
     result.push_back(it.GetMeasurementVector()[0]);
 
   return result;
 }
 
 IntensityProfile::Pointer mitk::CreateIntensityProfileFromVector(const std::vector<IntensityProfile::MeasurementType>& vector)
 {
   const IntensityProfile::InstanceIdentifier size = vector.size();
 
   IntensityProfile::Pointer result = IntensityProfile::New();
   result->Resize(size);
 
   for (IntensityProfile::InstanceIdentifier i = 0; i < size; ++i)
     result->SetMeasurement(i, 0, vector[i]);
 
   return result;
 }
diff --git a/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp b/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp
index 9ea804837b..0df829da33 100644
--- a/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp
+++ b/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp
@@ -1,189 +1,189 @@
 /*===================================================================
 
 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 "mitkImage.h"
 #include "mitkPicFileReader.h"
 #include "mitkPicHelper.h"
 #include "mitkSlicedGeometry3D.h"
 #include <itksys/SystemTools.hxx>
 #include <itkImageFileReader.h>
 #include <mitkTimeGeometry.h>
 
 #include <fstream>
 int mitkPicFileReaderTest(int argc, char* argv[])
 {
   MITK_TEST_BEGIN(mitkPicFileReaderTest)
 
   if(argc>=1)
   {
     if(itksys::SystemTools::FileLength(argv[1]) == 0)
     {
 
       mitk::PicFileReader::Pointer emptyFileReader = mitk::PicFileReader::New();
       emptyFileReader->SetFileName(argv[1]);
       MITK_TEST_FOR_EXCEPTION(itk::ImageFileReaderException,emptyFileReader->Update());
     }
     else
     {
 
 
       //independently read header of pic file
       mitkIpPicDescriptor *picheader=NULL;
       if(itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameExtension(argv[1])).find(".pic")!=std::string::npos)
       {
           picheader = mitkIpPicGetHeader(argv[1], NULL);
       }
       if(picheader==NULL)
       {
         std::cout<<"file not found/not a pic-file - test not applied [PASSED]"<<std::endl;
         std::cout<<"[TEST DONE]"<<std::endl;
         return EXIT_SUCCESS;
       }
       mitkIpPicGetTags(argv[1], picheader);
 
       //Read pic-Image from file
       mitk::PicFileReader::Pointer reader = mitk::PicFileReader::New();
         reader->SetFileName(argv[1]);
         reader->Update();
 
       std::cout << "Testing IsInitialized(): ";
       if(reader->GetOutput()->IsInitialized()==false)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing IsSliceSet(): ";
       if(reader->GetOutput()->IsSliceSet(0)==false)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing availability of geometry: ";
       if(reader->GetOutput()->GetGeometry()==NULL)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing type of geometry (TimeGeometry expected): ";
       mitk::TimeGeometry* timeGeometry;
       timeGeometry = reader->GetOutput()->GetTimeGeometry();
       if(timeGeometry==NULL)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing availability of first geometry contained in the TimeGeometry: ";
       if(timeGeometry->GetGeometryForTimeStep(0).IsNull())
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing type of first geometry contained in the TimeGeometry (SlicedGeometry3D expected): ";
       mitk::SlicedGeometry3D* slicedgeometry;
       slicedgeometry = dynamic_cast<mitk::SlicedGeometry3D*>(timeGeometry->GetGeometryForTimeStep(0).GetPointer());
       if(slicedgeometry==NULL)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing availability of first geometry contained in the SlicedGeometry3D: ";
-      mitk::PlaneGeometry* geometry2d = slicedgeometry->GetGeometry2D(0);
+      mitk::PlaneGeometry* geometry2d = slicedgeometry->GetPlaneGeometry(0);
       if(geometry2d==NULL)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing extent in units of first geometry contained in the SlicedGeometry3D: ";
       if((fabs(geometry2d->GetExtent(0)-picheader->n[0])>mitk::eps) || (fabs(geometry2d->GetExtent(1)-picheader->n[1])>mitk::eps))
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       std::cout << "Testing extent in units of image of SlicedGeometry3D: ";
       if((fabs(slicedgeometry->GetExtent(0)-picheader->n[0])>mitk::eps) || (fabs(slicedgeometry->GetExtent(1)-picheader->n[1])>mitk::eps)
         || (picheader->dim>2 && (fabs(slicedgeometry->GetExtent(2)-picheader->n[2])>mitk::eps))
         )
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
 
       std::cout << "Testing consistency of spacing from matrix and stored spacing in the first SlicedGeometry3D: ";
       mitk::Vector3D spacing;
       spacing[0] = slicedgeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0).two_norm();
       spacing[1] = slicedgeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1).two_norm();
       spacing[2] = slicedgeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).two_norm();
       mitk::Vector3D readspacing=slicedgeometry->GetSpacing();
       mitk::Vector3D dist = spacing-readspacing;
       if(dist.GetSquaredNorm()>mitk::eps)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       //independently read the overall spacing
       spacing.Fill(1);
       mitk::PicHelper::GetSpacing(picheader, spacing);
 
       std::cout << "Testing correct reading of overall spacing stored in the first SlicedGeometry3D: ";
       dist = spacing-readspacing;
       if(dist.GetSquaredNorm()>mitk::eps)
       {
         std::cout<<"[FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
 
       if(picheader->dim==4)
       {
         std::cout << "4D dataset: Testing that timebounds are not infinite: ";
         if((slicedgeometry->GetTimeBounds()[0] == mitk::ScalarTypeNumericTraits::NonpositiveMin()) &&
            (slicedgeometry->GetTimeBounds()[1] == mitk::ScalarTypeNumericTraits::max())
           )
         {
           std::cout<<"[FAILED]"<<std::endl;
           return EXIT_FAILURE;
         }
         std::cout<<"[PASSED]"<<std::endl;
       }
 
       mitkIpPicFree(picheader);
     }
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/IpPicSupport/mitkPicHelper.cpp b/Modules/IpPicSupport/mitkPicHelper.cpp
index 0907e2aeba..8e41d1a906 100644
--- a/Modules/IpPicSupport/mitkPicHelper.cpp
+++ b/Modules/IpPicSupport/mitkPicHelper.cpp
@@ -1,296 +1,296 @@
 /*===================================================================
 
 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 "mitkConfig.h"
 #include "mitkPicHelper.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #ifdef HAVE_IPDICOM
 #include "ipDicom/ipDicom.h"
 #endif /* HAVE_IPDICOM */
 
 bool mitk::PicHelper::GetSpacing(const mitkIpPicDescriptor* aPic, Vector3D & spacing)
 {
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
 
   mitkIpPicTSV_t *tsv;
   bool pixelSize = false;
 
   tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZE" );
   if(tsv==NULL)
   {
     tsv = mitkIpPicQueryTag( pic, "PIXEL SIZE" );
     pixelSize = true;
   }
   if(tsv)
   {
     bool tagFound = false;
     if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
     {
       if(tsv->bpe==32)
       {
         FillVector3D(spacing,((mitkIpFloat4_t*)tsv->value)[0], ((mitkIpFloat4_t*)tsv->value)[1],((mitkIpFloat4_t*)tsv->value)[2]);
         tagFound = true;
       }
       else
       if(tsv->bpe==64)
       {
         FillVector3D(spacing,((mitkIpFloat8_t*)tsv->value)[0], ((mitkIpFloat8_t*)tsv->value)[1],((mitkIpFloat8_t*)tsv->value)[2]);
         tagFound = true;
       }
     }
     if(tagFound && pixelSize)
     {
       tsv = mitkIpPicQueryTag( pic, "PIXEL SPACING" );
       if(tsv)
       {
         mitk::ScalarType zSpacing = 0;
         if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
         {
           if(tsv->bpe==32)
           {
             zSpacing = ((mitkIpFloat4_t*)tsv->value)[2];
           }
           else
           if(tsv->bpe==64)
           {
             zSpacing = ((mitkIpFloat8_t*)tsv->value)[2];
           }
           if(zSpacing != 0)
           {
             spacing[2] = zSpacing;
           }
         }
       }
     }
     if(tagFound) return true;
   }
 #ifdef HAVE_IPDICOM
   tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" );
   if( tsv )
   {
     void *data;
     mitkIpUInt4_t len;
     mitkIpFloat8_t spacing_z = 0;
     mitkIpFloat8_t thickness = 1;
     mitkIpFloat8_t fx = 1;
     mitkIpFloat8_t fy = 1;
     bool ok=false;
 
     if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0088, &data, &len ) )
     {
       ok=true;
       sscanf( (char *) data, "%lf", &spacing_z );
 //        itkGenericOutputMacro( "spacing:  " << spacing_z << " mm");
     }
     if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0050, &data, &len ) )
     {
       ok=true;
       sscanf( (char *) data, "%lf", &thickness );
 //        itkGenericOutputMacro( "thickness: " << thickness << " mm");
 
       if( thickness == 0 )
         thickness = 1;
     }
     if( dicomFindElement( (unsigned char *) tsv->value, 0x0028, 0x0030, &data, &len )
       && len>0 && ((char *)data)[0] )
     {
       sscanf( (char *) data, "%lf\\%lf", &fy, &fx );    // row / column value
 //        itkGenericOutputMacro( "fx, fy: " << fx << "/" << fy  << " mm");
     }
     else
       ok=false;
     if(ok)
       FillVector3D(spacing, fx, fy,( spacing_z > 0 ? spacing_z : thickness));
     return ok;
   }
 #endif /* HAVE_IPDICOM */
   if(spacing[0]<=0 || spacing[1]<=0 || spacing[2]<=0)
   {
     itkGenericOutputMacro(<< "illegal spacing by pic tag: " << spacing << ". Setting spacing to (1,1,1).");
     spacing.Fill(1);
   }
   return false;
 }
 
 bool mitk::PicHelper::GetTimeSpacing(const mitkIpPicDescriptor* aPic, float& timeSpacing)
 {
 
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
 
   mitkIpPicTSV_t *tsv;
 
   tsv = mitkIpPicQueryTag( pic, "PIXEL SIZE" );
   if(tsv)
   {
     timeSpacing = ((mitkIpFloat4_t*)tsv->value)[3];
     if( timeSpacing <=0 ) timeSpacing = 1;
   }
   else timeSpacing = 1;
   return true;
 }
 
 bool mitk::PicHelper::SetSpacing(const mitkIpPicDescriptor* aPic, SlicedGeometry3D* slicedgeometry)
 {
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
 
   Vector3D spacing(slicedgeometry->GetSpacing());
 
   mitkIpPicTSV_t *tsv;
   if ( (tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZES" )) != NULL)
   {
     int count = tsv->n[1];
     float* value = (float*) tsv->value;
     mitk::Vector3D pixelSize;
     spacing.Fill(0);
 
     for ( int s=0; s < count; s++ )
     {
       pixelSize[0] = (ScalarType) *value++;
       pixelSize[1] = (ScalarType) *value++;
       pixelSize[2] = (ScalarType) *value++;
       spacing += pixelSize;
     }
     spacing *= 1.0f/count;
     slicedgeometry->SetSpacing(spacing);
 
     itkGenericOutputMacro(<< "the slices are inhomogeneous" );
   }
   else
     if(GetSpacing(pic, spacing))
     {
       slicedgeometry->SetSpacing(spacing);
       return true;
     }
     return false;
 }
 
 void mitk::PicHelper::InitializeEvenlySpaced(const mitkIpPicDescriptor* pic, unsigned int slices, SlicedGeometry3D* slicedgeometry)
 {
   assert(pic!=NULL);
   assert(slicedgeometry!=NULL);
 
   mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
 
   mitkIpPicTSV_t *geometryTag;
   if ( (geometryTag = mitkIpPicQueryTag( const_cast<mitkIpPicDescriptor*>(pic), "ISG" )) != NULL)
   {
     mitk::Point3D  origin;
     mitk::Vector3D rightVector;
     mitk::Vector3D downVector;
     mitk::Vector3D spacing;
 
     mitk::vtk2itk(((float*)geometryTag->value+0), origin);
     mitk::vtk2itk(((float*)geometryTag->value+3), rightVector);
     mitk::vtk2itk(((float*)geometryTag->value+6), downVector);
     mitk::vtk2itk(((float*)geometryTag->value+9), spacing);
 
     mitk::PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
     planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightVector, downVector, &spacing);
     planegeometry->SetOrigin(origin);
     slicedgeometry->InitializeEvenlySpaced(planegeometry, slices);
   }
   else
   {
     Vector3D spacing;
     spacing.Fill(1);
     GetSpacing(pic, spacing);
     planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], spacing);
     slicedgeometry->InitializeEvenlySpaced(planegeometry, spacing[2], slices);
   }
 
   if(pic->dim>=4)
   {
     float ts = 0;
     GetTimeSpacing(pic, ts);
     TimeBounds timebounds;
     timebounds[0] = 0.0;
     timebounds[1] = ts;
     slicedgeometry->SetTimeBounds(timebounds);
   }
 }
 
-bool mitk::PicHelper::SetGeometry2D(const mitkIpPicDescriptor* aPic, int s, SlicedGeometry3D* slicedgeometry)
+bool mitk::PicHelper::SetPlaneGeometry(const mitkIpPicDescriptor* aPic, int s, SlicedGeometry3D* slicedgeometry)
 {
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
   if((pic!=NULL) && (slicedgeometry->IsValidSlice(s)))
   {
     //construct standard view
     mitk::Point3D origin;
     mitk::Vector3D rightDV, bottomDV;
     mitkIpPicTSV_t *tsv;
     if ( (tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZES" )) != NULL)
     {
       unsigned int count = (unsigned int) tsv->n[1];
       float* value = (float*) tsv->value;
       mitk::Vector3D pixelSize;
       ScalarType zPosition = 0.0f;
 
       if(s >= 0)
       {
         if(count < (unsigned int) s)
           return false;
         count = s;
       }
       else
       {
         if(count < slicedgeometry->GetSlices())
           return false;
         count = slicedgeometry->GetSlices();
       }
 
       unsigned int slice;
       for (slice=0; slice < count; ++slice )
       {
         pixelSize[0] = (ScalarType) *value++;
         pixelSize[1] = (ScalarType) *value++;
         pixelSize[2] = (ScalarType) *value++;
 
         zPosition += pixelSize[2] / 2.0f;    // first half slice thickness
 
         if((s==-1) || (slice== (unsigned int) s))
         {
           Vector3D spacing;
           spacing = pixelSize;
           FillVector3D(origin,   0,         0, zPosition);
           FillVector3D(rightDV,  pic->n[0], 0,         0);
           FillVector3D(bottomDV, 0,         pic->n[1], 0);
 
           mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
           planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &spacing);
           planegeometry->SetOrigin(origin);
-          slicedgeometry->SetGeometry2D(planegeometry, s);
+          slicedgeometry->SetPlaneGeometry(planegeometry, s);
         }
 
         zPosition += pixelSize[2] / 2.0f;  // second half slice thickness
       }
 
     }
     else
     {
       FillVector3D(origin,0,0,s); slicedgeometry->IndexToWorld(origin, origin);
       FillVector3D(rightDV,pic->n[0],0,0);
       FillVector3D(bottomDV,0,pic->n[1],0);
 
       mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
       planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &slicedgeometry->GetSpacing());
       planegeometry->SetOrigin(origin);
-      slicedgeometry->SetGeometry2D(planegeometry, s);
+      slicedgeometry->SetPlaneGeometry(planegeometry, s);
     }
     return true;
   }
   return false;
 }
diff --git a/Modules/IpPicSupport/mitkPicHelper.h b/Modules/IpPicSupport/mitkPicHelper.h
index 11a18b6d1c..583bace240 100644
--- a/Modules/IpPicSupport/mitkPicHelper.h
+++ b/Modules/IpPicSupport/mitkPicHelper.h
@@ -1,52 +1,52 @@
 /*===================================================================
 
 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 MITKPICHELPER_H_HEADER_INCLUDED_C1F4DAB4
 #define MITKPICHELPER_H_HEADER_INCLUDED_C1F4DAB4
 
 #include <MitkIpPicSupportExports.h>
 #include "mitkVector.h"
 #include <mitkIpPic.h>
 
 namespace mitk {
 
 class SlicedGeometry3D;
 
 //##Documentation
 //## @brief Internal class for managing references on sub-images
 //## @ingroup Data
 class MitkIpPicSupport_EXPORT PicHelper
 {
 public:
   static const char *GetNameOfClass() { return "PicHelper"; }
 
   static bool GetSpacing(const mitkIpPicDescriptor* pic, Vector3D & spacing);
 
   static bool SetSpacing(const mitkIpPicDescriptor* pic, SlicedGeometry3D* slicedgeometry);
 
   static bool GetTimeSpacing(const mitkIpPicDescriptor* pic, float& timeSpacing);
 
   static void InitializeEvenlySpaced(const mitkIpPicDescriptor* pic, unsigned int slices, SlicedGeometry3D* slicedgeometry);
 
-  static bool SetGeometry2D(const mitkIpPicDescriptor* pic, int s, SlicedGeometry3D* slicedgeometry);
+  static bool SetPlaneGeometry(const mitkIpPicDescriptor* pic, int s, SlicedGeometry3D* slicedgeometry);
 };
 
 } // namespace mitk
 
 
 
 #endif /* MITKPICHELPER_H_HEADER_INCLUDED_C1F4DAB4 */
diff --git a/Modules/IpPicSupportIO/Internal/mitkPicHelper.cpp b/Modules/IpPicSupportIO/Internal/mitkPicHelper.cpp
index 0907e2aeba..8e41d1a906 100644
--- a/Modules/IpPicSupportIO/Internal/mitkPicHelper.cpp
+++ b/Modules/IpPicSupportIO/Internal/mitkPicHelper.cpp
@@ -1,296 +1,296 @@
 /*===================================================================
 
 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 "mitkConfig.h"
 #include "mitkPicHelper.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #ifdef HAVE_IPDICOM
 #include "ipDicom/ipDicom.h"
 #endif /* HAVE_IPDICOM */
 
 bool mitk::PicHelper::GetSpacing(const mitkIpPicDescriptor* aPic, Vector3D & spacing)
 {
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
 
   mitkIpPicTSV_t *tsv;
   bool pixelSize = false;
 
   tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZE" );
   if(tsv==NULL)
   {
     tsv = mitkIpPicQueryTag( pic, "PIXEL SIZE" );
     pixelSize = true;
   }
   if(tsv)
   {
     bool tagFound = false;
     if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
     {
       if(tsv->bpe==32)
       {
         FillVector3D(spacing,((mitkIpFloat4_t*)tsv->value)[0], ((mitkIpFloat4_t*)tsv->value)[1],((mitkIpFloat4_t*)tsv->value)[2]);
         tagFound = true;
       }
       else
       if(tsv->bpe==64)
       {
         FillVector3D(spacing,((mitkIpFloat8_t*)tsv->value)[0], ((mitkIpFloat8_t*)tsv->value)[1],((mitkIpFloat8_t*)tsv->value)[2]);
         tagFound = true;
       }
     }
     if(tagFound && pixelSize)
     {
       tsv = mitkIpPicQueryTag( pic, "PIXEL SPACING" );
       if(tsv)
       {
         mitk::ScalarType zSpacing = 0;
         if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
         {
           if(tsv->bpe==32)
           {
             zSpacing = ((mitkIpFloat4_t*)tsv->value)[2];
           }
           else
           if(tsv->bpe==64)
           {
             zSpacing = ((mitkIpFloat8_t*)tsv->value)[2];
           }
           if(zSpacing != 0)
           {
             spacing[2] = zSpacing;
           }
         }
       }
     }
     if(tagFound) return true;
   }
 #ifdef HAVE_IPDICOM
   tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" );
   if( tsv )
   {
     void *data;
     mitkIpUInt4_t len;
     mitkIpFloat8_t spacing_z = 0;
     mitkIpFloat8_t thickness = 1;
     mitkIpFloat8_t fx = 1;
     mitkIpFloat8_t fy = 1;
     bool ok=false;
 
     if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0088, &data, &len ) )
     {
       ok=true;
       sscanf( (char *) data, "%lf", &spacing_z );
 //        itkGenericOutputMacro( "spacing:  " << spacing_z << " mm");
     }
     if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0050, &data, &len ) )
     {
       ok=true;
       sscanf( (char *) data, "%lf", &thickness );
 //        itkGenericOutputMacro( "thickness: " << thickness << " mm");
 
       if( thickness == 0 )
         thickness = 1;
     }
     if( dicomFindElement( (unsigned char *) tsv->value, 0x0028, 0x0030, &data, &len )
       && len>0 && ((char *)data)[0] )
     {
       sscanf( (char *) data, "%lf\\%lf", &fy, &fx );    // row / column value
 //        itkGenericOutputMacro( "fx, fy: " << fx << "/" << fy  << " mm");
     }
     else
       ok=false;
     if(ok)
       FillVector3D(spacing, fx, fy,( spacing_z > 0 ? spacing_z : thickness));
     return ok;
   }
 #endif /* HAVE_IPDICOM */
   if(spacing[0]<=0 || spacing[1]<=0 || spacing[2]<=0)
   {
     itkGenericOutputMacro(<< "illegal spacing by pic tag: " << spacing << ". Setting spacing to (1,1,1).");
     spacing.Fill(1);
   }
   return false;
 }
 
 bool mitk::PicHelper::GetTimeSpacing(const mitkIpPicDescriptor* aPic, float& timeSpacing)
 {
 
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
 
   mitkIpPicTSV_t *tsv;
 
   tsv = mitkIpPicQueryTag( pic, "PIXEL SIZE" );
   if(tsv)
   {
     timeSpacing = ((mitkIpFloat4_t*)tsv->value)[3];
     if( timeSpacing <=0 ) timeSpacing = 1;
   }
   else timeSpacing = 1;
   return true;
 }
 
 bool mitk::PicHelper::SetSpacing(const mitkIpPicDescriptor* aPic, SlicedGeometry3D* slicedgeometry)
 {
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
 
   Vector3D spacing(slicedgeometry->GetSpacing());
 
   mitkIpPicTSV_t *tsv;
   if ( (tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZES" )) != NULL)
   {
     int count = tsv->n[1];
     float* value = (float*) tsv->value;
     mitk::Vector3D pixelSize;
     spacing.Fill(0);
 
     for ( int s=0; s < count; s++ )
     {
       pixelSize[0] = (ScalarType) *value++;
       pixelSize[1] = (ScalarType) *value++;
       pixelSize[2] = (ScalarType) *value++;
       spacing += pixelSize;
     }
     spacing *= 1.0f/count;
     slicedgeometry->SetSpacing(spacing);
 
     itkGenericOutputMacro(<< "the slices are inhomogeneous" );
   }
   else
     if(GetSpacing(pic, spacing))
     {
       slicedgeometry->SetSpacing(spacing);
       return true;
     }
     return false;
 }
 
 void mitk::PicHelper::InitializeEvenlySpaced(const mitkIpPicDescriptor* pic, unsigned int slices, SlicedGeometry3D* slicedgeometry)
 {
   assert(pic!=NULL);
   assert(slicedgeometry!=NULL);
 
   mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
 
   mitkIpPicTSV_t *geometryTag;
   if ( (geometryTag = mitkIpPicQueryTag( const_cast<mitkIpPicDescriptor*>(pic), "ISG" )) != NULL)
   {
     mitk::Point3D  origin;
     mitk::Vector3D rightVector;
     mitk::Vector3D downVector;
     mitk::Vector3D spacing;
 
     mitk::vtk2itk(((float*)geometryTag->value+0), origin);
     mitk::vtk2itk(((float*)geometryTag->value+3), rightVector);
     mitk::vtk2itk(((float*)geometryTag->value+6), downVector);
     mitk::vtk2itk(((float*)geometryTag->value+9), spacing);
 
     mitk::PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
     planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightVector, downVector, &spacing);
     planegeometry->SetOrigin(origin);
     slicedgeometry->InitializeEvenlySpaced(planegeometry, slices);
   }
   else
   {
     Vector3D spacing;
     spacing.Fill(1);
     GetSpacing(pic, spacing);
     planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], spacing);
     slicedgeometry->InitializeEvenlySpaced(planegeometry, spacing[2], slices);
   }
 
   if(pic->dim>=4)
   {
     float ts = 0;
     GetTimeSpacing(pic, ts);
     TimeBounds timebounds;
     timebounds[0] = 0.0;
     timebounds[1] = ts;
     slicedgeometry->SetTimeBounds(timebounds);
   }
 }
 
-bool mitk::PicHelper::SetGeometry2D(const mitkIpPicDescriptor* aPic, int s, SlicedGeometry3D* slicedgeometry)
+bool mitk::PicHelper::SetPlaneGeometry(const mitkIpPicDescriptor* aPic, int s, SlicedGeometry3D* slicedgeometry)
 {
   mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
   if((pic!=NULL) && (slicedgeometry->IsValidSlice(s)))
   {
     //construct standard view
     mitk::Point3D origin;
     mitk::Vector3D rightDV, bottomDV;
     mitkIpPicTSV_t *tsv;
     if ( (tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZES" )) != NULL)
     {
       unsigned int count = (unsigned int) tsv->n[1];
       float* value = (float*) tsv->value;
       mitk::Vector3D pixelSize;
       ScalarType zPosition = 0.0f;
 
       if(s >= 0)
       {
         if(count < (unsigned int) s)
           return false;
         count = s;
       }
       else
       {
         if(count < slicedgeometry->GetSlices())
           return false;
         count = slicedgeometry->GetSlices();
       }
 
       unsigned int slice;
       for (slice=0; slice < count; ++slice )
       {
         pixelSize[0] = (ScalarType) *value++;
         pixelSize[1] = (ScalarType) *value++;
         pixelSize[2] = (ScalarType) *value++;
 
         zPosition += pixelSize[2] / 2.0f;    // first half slice thickness
 
         if((s==-1) || (slice== (unsigned int) s))
         {
           Vector3D spacing;
           spacing = pixelSize;
           FillVector3D(origin,   0,         0, zPosition);
           FillVector3D(rightDV,  pic->n[0], 0,         0);
           FillVector3D(bottomDV, 0,         pic->n[1], 0);
 
           mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
           planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &spacing);
           planegeometry->SetOrigin(origin);
-          slicedgeometry->SetGeometry2D(planegeometry, s);
+          slicedgeometry->SetPlaneGeometry(planegeometry, s);
         }
 
         zPosition += pixelSize[2] / 2.0f;  // second half slice thickness
       }
 
     }
     else
     {
       FillVector3D(origin,0,0,s); slicedgeometry->IndexToWorld(origin, origin);
       FillVector3D(rightDV,pic->n[0],0,0);
       FillVector3D(bottomDV,0,pic->n[1],0);
 
       mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
       planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &slicedgeometry->GetSpacing());
       planegeometry->SetOrigin(origin);
-      slicedgeometry->SetGeometry2D(planegeometry, s);
+      slicedgeometry->SetPlaneGeometry(planegeometry, s);
     }
     return true;
   }
   return false;
 }
diff --git a/Modules/IpPicSupportIO/Internal/mitkPicHelper.h b/Modules/IpPicSupportIO/Internal/mitkPicHelper.h
index a7fe95264b..7cd0c738ac 100644
--- a/Modules/IpPicSupportIO/Internal/mitkPicHelper.h
+++ b/Modules/IpPicSupportIO/Internal/mitkPicHelper.h
@@ -1,50 +1,50 @@
 /*===================================================================
 
 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 MITKPICHELPER_H_HEADER_INCLUDED_C1F4DAB4
 #define MITKPICHELPER_H_HEADER_INCLUDED_C1F4DAB4
 
 #include "mitkVector.h"
 #include <mitkIpPic.h>
 
 namespace mitk {
 
 class SlicedGeometry3D;
 
 //##Documentation
 //## @brief Internal class for managing references on sub-images
 class PicHelper
 {
 public:
   static const char *GetNameOfClass() { return "PicHelper"; }
 
   static bool GetSpacing(const mitkIpPicDescriptor* pic, Vector3D & spacing);
 
   static bool SetSpacing(const mitkIpPicDescriptor* pic, SlicedGeometry3D* slicedgeometry);
 
   static bool GetTimeSpacing(const mitkIpPicDescriptor* pic, float& timeSpacing);
 
   static void InitializeEvenlySpaced(const mitkIpPicDescriptor* pic, unsigned int slices, SlicedGeometry3D* slicedgeometry);
 
-  static bool SetGeometry2D(const mitkIpPicDescriptor* pic, int s, SlicedGeometry3D* slicedgeometry);
+  static bool SetPlaneGeometry(const mitkIpPicDescriptor* pic, int s, SlicedGeometry3D* slicedgeometry);
 };
 
 } // namespace mitk
 
 
 
 #endif /* MITKPICHELPER_H_HEADER_INCLUDED_C1F4DAB4 */
diff --git a/Modules/MapperExt/mitkMeshMapper2D.cpp b/Modules/MapperExt/mitkMeshMapper2D.cpp
index c6cfb087d1..0339493695 100644
--- a/Modules/MapperExt/mitkMeshMapper2D.cpp
+++ b/Modules/MapperExt/mitkMeshMapper2D.cpp
@@ -1,481 +1,481 @@
 /*===================================================================
 
 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 "mitkMeshMapper2D.h"
 #include "mitkMesh.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkLine.h"
 #include "mitkGL.h"
 
 #include <vtkLinearTransform.h>
 
 #include <algorithm>
 
 const float selectedColor[]={1.0,0.0,0.6}; //for selected!
 
 mitk::MeshMapper2D::MeshMapper2D()
 {
 }
 
 
 mitk::MeshMapper2D::~MeshMapper2D()
 {
 }
 
 const mitk::Mesh *mitk::MeshMapper2D::GetInput(void)
 {
     return static_cast<const mitk::Mesh * > ( GetDataNode()->GetData() );
 }
 
 // Return whether a point is "smaller" than the second
 static bool point3DSmaller( const mitk::Point3D& elem1, const mitk::Point3D& elem2 )
 {
   if(elem1[0]!=elem2[0])
     return elem1[0] < elem2[0];
   if(elem1[1]!=elem2[1])
     return elem1[1] < elem2[1];
   return elem1[2] < elem2[2];
 }
 
 void mitk::MeshMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
 
     bool visible = true;
 
     GetDataNode()->GetVisibility(visible, renderer, "visible");
 
     if(!visible) return;
 
   //  @FIXME: Logik fuer update
   bool updateNeccesary = true;
 
   if (updateNeccesary)
   {
   //aus GenerateData
     mitk::Mesh::Pointer input = const_cast<mitk::Mesh*>(this->GetInput());
 
     // Get the TimeGeometry of the input object
     const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
     if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
     {
       return;
     }
 
     //
     // get the world time
     //
-    const PlaneGeometry* worldGeometry = renderer->GetCurrentWorldGeometry2D();
+    const PlaneGeometry* worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
     assert( worldGeometry != NULL );
     ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
 
     //
     // convert the world time in time steps of the input object
     //
     int timeStep=0;
     if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
       timeStep = inputTimeGeometry->TimePointToTimeStep( time );
     if ( inputTimeGeometry->IsValidTimeStep( timeStep ) == false )
     {
       return;
     }
 
 
     mitk::Mesh::MeshType::Pointer itkMesh = input->GetMesh( timeStep );
 
     if ( itkMesh.GetPointer() == NULL)
     {
       return;
     }
 
 
     mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
     assert(displayGeometry.IsNotNull());
 
-    const PlaneGeometry* worldplanegeometry = dynamic_cast<const PlaneGeometry*>(renderer->GetCurrentWorldGeometry2D());
+    const PlaneGeometry* worldplanegeometry = dynamic_cast<const PlaneGeometry*>(renderer->GetCurrentWorldPlaneGeometry());
 
     //apply color and opacity read from the PropertyList
     ApplyColorAndOpacityProperties(renderer);
 
     vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
 
     //List of the Points
     Mesh::DataType::PointsContainerConstIterator it, end;
     it=itkMesh->GetPoints()->Begin();
     end=itkMesh ->GetPoints()->End();
 
     //iterator on the additional data of each point
     Mesh::PointDataIterator dataIt;//, dataEnd;
     dataIt=itkMesh->GetPointData()->Begin();
 
     //for switching back to old color after using selected color
     float unselectedColor[4];
     glGetFloatv(GL_CURRENT_COLOR,unselectedColor);
 
     while(it!=end)
     {
       mitk::Point3D p, projected_p;
       float vtkp[3];
 
       itk2vtk(it->Value(), vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
       Vector3D diff=p-projected_p;
       if(diff.GetSquaredNorm()<4.0)
       {
         Point2D pt2d, tmp;
         displayGeometry->Map(projected_p, pt2d);
         displayGeometry->WorldToDisplay(pt2d, pt2d);
 
         Vector2D horz,vert;
         horz[0]=5; horz[1]=0;
         vert[0]=0; vert[1]=5;
 
         //check if the point is to be marked as selected
         if (dataIt->Value().selected)
         {
           horz[0]=8;
           vert[1]=8;
           glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
 
           switch (dataIt->Value().pointSpec)
           {
           case PTSTART:
             {
               //a quad
               glBegin (GL_LINE_LOOP);
                 tmp=pt2d-horz+vert;      glVertex2dv(&tmp[0]);
                 tmp=pt2d+horz+vert;      glVertex2dv(&tmp[0]);
                 tmp=pt2d+horz-vert;      glVertex2dv(&tmp[0]);
                 tmp=pt2d-horz-vert;      glVertex2dv(&tmp[0]);
               glEnd ();
             }
             break;
           case PTUNDEFINED:
             {
               //a diamond around the point
               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 ();
             }
             break;
           default:
             break;
           }//switch
 
           //the actual point
           glBegin (GL_POINTS);
             tmp=pt2d;             glVertex2dv(&tmp[0]);
           glEnd ();
         }
         else //if not selected
         {
           glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
           switch (dataIt->Value().pointSpec)
           {
           case PTSTART:
             {
               //a quad
               glBegin (GL_LINE_LOOP);
                 tmp=pt2d-horz+vert;      glVertex2dv(&tmp[0]);
                 tmp=pt2d+horz+vert;      glVertex2dv(&tmp[0]);
                 tmp=pt2d+horz-vert;      glVertex2dv(&tmp[0]);
                 tmp=pt2d-horz-vert;      glVertex2dv(&tmp[0]);
               glEnd ();
             }
           case PTUNDEFINED:
             {
               //drawing crosses
               glBegin (GL_LINES);
                   tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
                   tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
                   tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
                   tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
               glEnd ();
             }
     default:
             {
         break;
             }
           }//switch
         }//else
       }
       ++it;
       ++dataIt;
     }
 
     //now connect the lines inbetween
     mitk::Mesh::PointType thisPoint; thisPoint.Fill(0);
     Point2D *firstOfCell = NULL;
     Point2D *lastPoint = NULL;
     unsigned int lastPointId = 0;
     bool lineSelected = false;
 
     Point3D firstOfCell3D;
     Point3D lastPoint3D;
     bool first;
     mitk::Line<mitk::ScalarType> line;
     std::vector<mitk::Point3D> intersectionPoints;
     double t;
 
     //iterate through all cells and then iterate through all indexes of points in that cell
     Mesh::CellIterator cellIt, cellEnd;
     Mesh::CellDataIterator cellDataIt;//, cellDataEnd;
     Mesh::PointIdIterator cellIdIt, cellIdEnd;
 
     cellIt = itkMesh->GetCells()->Begin();
     cellEnd = itkMesh->GetCells()->End();
     cellDataIt = itkMesh->GetCellData()->Begin();
 
     while (cellIt != cellEnd)
     {
       unsigned int numOfPointsInCell = cellIt->Value()->GetNumberOfPoints();
       if (numOfPointsInCell>1)
       {
         //iterate through all id's in the cell
         cellIdIt = cellIt->Value()->PointIdsBegin();
         cellIdEnd = cellIt->Value()->PointIdsEnd();
 
         firstOfCell3D = input->GetPoint(*cellIdIt,timeStep);
 
         intersectionPoints.clear();
         intersectionPoints.reserve(numOfPointsInCell);
 
         first = true;
 
         while(cellIdIt != cellIdEnd)
         {
           lastPoint3D = thisPoint;
 
           thisPoint = input->GetPoint(*cellIdIt,timeStep);
 
           //search in data (vector<> selectedLines) if the index of the point is set. if so, then the line is selected.
           lineSelected = false;
           Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
 
           //a line between 1(lastPoint) and 2(pt2d) has the Id 1, so look for the Id of lastPoint
           //since we only start, if we have more than one point in the cell, lastPointId is initiated with 0
           Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
           if (position != selectedLines.end())
           {
             lineSelected = true;
           }
 
           mitk::Point3D p, projected_p;
           float vtkp[3];
           itk2vtk(thisPoint, vtkp);
           transform->TransformPoint(vtkp, vtkp);
           vtk2itk(vtkp,p);
           displayGeometry->Project(p, projected_p);
           Vector3D diff=p-projected_p;
           if(diff.GetSquaredNorm()<4.0)
           {
             Point2D pt2d, tmp;
             displayGeometry->Map(projected_p, pt2d);
             displayGeometry->WorldToDisplay(pt2d, pt2d);
 
             if (lastPoint == NULL)
             {
               //set the first point in the cell. This point in needed to close the polygon
               firstOfCell = new Point2D;
               *firstOfCell = pt2d;
               lastPoint = new Point2D;
               *lastPoint = pt2d;
               lastPointId = *cellIdIt;
             }
             else
             {
               if (lineSelected)
               {
                 glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
                 //a line from lastPoint to thisPoint
                 glBegin (GL_LINES);
                   glVertex2dv(&(*lastPoint)[0]);
                   glVertex2dv(&pt2d[0]);
                 glEnd ();
               }
               else //if not selected
               {
                 glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
                 //drawing crosses
                 glBegin (GL_LINES);
                   glVertex2dv(&(*lastPoint)[0]);
                   glVertex2dv(&pt2d[0]);
                 glEnd ();
               }
               //to draw the line to the next in iteration step
               *lastPoint = pt2d;
               //and to search for the selection state of the line
               lastPointId = *cellIdIt;
             }//if..else
           }//if <4.0
 
           //fill off-plane polygon part 1
           if((!first) && (worldplanegeometry!=NULL))
           {
             line.SetPoints(lastPoint3D, thisPoint);
             if(worldplanegeometry->IntersectionPointParam(line, t) &&
               ((t>=0) && (t<=1))
               )
             {
               intersectionPoints.push_back(line.GetPoint(t));
             }
           }
           ++cellIdIt;
           first=false;
         }//while cellIdIter
 
         //closed polygon?
         if ( cellDataIt->Value().closed )
         {
           //close the polygon if needed
           if( firstOfCell != NULL )
           {
             lineSelected = false;
             Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
             Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
             if (position != selectedLines.end())//found the index
             {
               glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
               //a line from lastPoint to firstPoint
               glBegin (GL_LINES);
                 glVertex2dv(&(*lastPoint)[0]);
                 glVertex2dv(&(*firstOfCell)[0]);
               glEnd ();
             }
             else
             {
               glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
               glBegin (GL_LINES);
                 glVertex2dv(&(*lastPoint)[0]);
                 glVertex2dv(&(*firstOfCell)[0]);
               glEnd ();
             }
           }
         }//if closed
 
         //Axis-aligned bounding box(AABB) around the cell if selected and set in Property
         bool showBoundingBox;
         if (dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox")) == NULL)
           showBoundingBox = false;
         else
           showBoundingBox = dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox"))->GetValue();
 
         if(showBoundingBox)
         {
           if (cellDataIt->Value().selected)
           {
             mitk::Mesh::DataType::BoundingBoxPointer aABB = input->GetBoundingBoxFromCell(cellIt->Index());
             if (aABB.IsNotNull())
             {
               mitk::Mesh::PointType min, max;
               min = aABB->GetMinimum();
               max = aABB->GetMaximum();
 
               //project to the displayed geometry
               Point2D min2D, max2D;
               Point3D p, projected_p;
               float vtkp[3];
               itk2vtk(min, vtkp);
               transform->TransformPoint(vtkp, vtkp);
               vtk2itk(vtkp,p);
               displayGeometry->Project(p, projected_p);
               displayGeometry->Map(projected_p, min2D);
               displayGeometry->WorldToDisplay(min2D, min2D);
 
               itk2vtk(max, vtkp);
               transform->TransformPoint(vtkp, vtkp);
               vtk2itk(vtkp,p);
               displayGeometry->Project(p, projected_p);
               Vector3D diff=p-projected_p;
               if(diff.GetSquaredNorm()<4.0)
               {
                 displayGeometry->Map(projected_p, max2D);
                 displayGeometry->WorldToDisplay(max2D, max2D);
 
                 //draw the BoundingBox
                 glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
                 //a line from lastPoint to firstPoint
                 glBegin(GL_LINE_LOOP);
                   glVertex2f(min2D[0], min2D[1]);
                   glVertex2f(min2D[0], max2D[1]);
                   glVertex2f(max2D[0], max2D[1]);
                   glVertex2f(max2D[0], min2D[1]);
                 glEnd();
               }//draw bounding-box
             }//bounding-box exists
           }//cell selected
         }//show bounding-box
 
         //fill off-plane polygon part 2
         if(worldplanegeometry!=NULL)
         {
           //consider line from last to first
           line.SetPoints(thisPoint, firstOfCell3D);
           if(worldplanegeometry->IntersectionPointParam(line, t) &&
             ((t>=0) && (t<=1))
             )
           {
             intersectionPoints.push_back(line.GetPoint(t));
           }
           std::sort(intersectionPoints.begin(), intersectionPoints.end(), point3DSmaller);
           std::vector<mitk::Point3D>::iterator it, end;
           end=intersectionPoints.end();
           if((intersectionPoints.size()%2)!=0)
           {
             --end; //ensure even number of intersection-points
           }
           double p[2];
           Point3D pt3d;
           Point2D pt2d;
           for ( it = intersectionPoints.begin( ); it != end; ++it )
           {
             glBegin (GL_LINES);
               displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
               p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
               ++it;
               displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
               p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
             glEnd ();
           }
           if(it!=intersectionPoints.end())
           {
             glBegin (GL_LINES);
               displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
               p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
               p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
             glEnd ();
           }
         }//fill off-plane polygon part 2
       }//if numOfPointsInCell>1
       delete firstOfCell;
       delete lastPoint;
       lastPoint = NULL;
       firstOfCell = NULL;
       lastPointId = 0;
       ++cellIt;
       ++cellDataIt;
     }
   }
 }
diff --git a/Modules/MapperExt/mitkUnstructuredGridMapper2D.cpp b/Modules/MapperExt/mitkUnstructuredGridMapper2D.cpp
index 85b6fcfd85..8442ff18f3 100644
--- a/Modules/MapperExt/mitkUnstructuredGridMapper2D.cpp
+++ b/Modules/MapperExt/mitkUnstructuredGridMapper2D.cpp
@@ -1,574 +1,574 @@
 /*===================================================================
 
 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 <mitkGL.h>
 #include "mitkUnstructuredGridMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkUnstructuredGrid.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkProperties.h"
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkVtkMapper3D.h"
 
 #include <vtkUnstructuredGrid.h>
 #include <vtkPlane.h>
 #include <vtkCellArray.h>
 #include <vtkLookupTable.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkLinearTransform.h>
 #include <vtkVolume.h>
 #include <vtkAssembly.h>
 #include <vtkVolumeProperty.h>
 #include <vtkAbstractMapper3D.h>
 #include <vtkAbstractVolumeMapper.h>
 #include <vtkScalarsToColors.h>
 #include <vtkPiecewiseFunction.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkProp3DCollection.h>
 
 #include "Internal/vtkPointSetSlicer.h"
 
 void mitk::UnstructuredGridMapper2D::GenerateDataForRenderer( mitk::BaseRenderer* renderer )
 {
 
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   if(needGenerateData)
   {
     ls->UpdateGenerateDataTime();
 
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     if ( node.IsNull() )
       return;
 
     if (!node->GetProperty(m_ScalarMode, "scalar mode"))
     {
       m_ScalarMode = mitk::VtkScalarModeProperty::New(0);
     }
 
     if (!node->GetProperty(m_ScalarVisibility, "scalar visibility"))
     {
       m_ScalarVisibility = mitk::BoolProperty::New(true);
     }
 
     if (!node->GetProperty(m_Outline, "outline polygons"))
     {
       m_Outline = mitk::BoolProperty::New(false);
     }
 
     if (!node->GetProperty(m_Color, "color"))
     {
       m_Color = mitk::ColorProperty::New(1.0f, 1.0f, 1.0f);
     }
 
     if (!node->GetProperty(m_LineWidth, "line width"))
     {
       m_LineWidth = mitk::IntProperty::New(1);
     }
 
   }
   mitk::BaseData::Pointer input = const_cast<mitk::BaseData*>( GetDataNode()->GetData() );
   assert( input );
 
   input->Update();
 
   if (m_VtkPointSet) m_VtkPointSet->UnRegister(0);
   m_VtkPointSet = this->GetVtkPointSet(renderer);
   assert(m_VtkPointSet);
   m_VtkPointSet->Register(0);
 
   if (m_ScalarVisibility->GetValue())
   {
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     mitk::TransferFunctionProperty::Pointer transferFuncProp;
     node->GetProperty(transferFuncProp, "TransferFunction", renderer);
     if (transferFuncProp.IsNotNull())
     {
       mitk::TransferFunction::Pointer tf = transferFuncProp->GetValue();
       if (m_ScalarsToColors) m_ScalarsToColors->UnRegister(0);
       m_ScalarsToColors = static_cast<vtkScalarsToColors*>(tf->GetColorTransferFunction());
       m_ScalarsToColors->Register(0);
 
       if (m_ScalarsToOpacity) m_ScalarsToOpacity->UnRegister(0);
       m_ScalarsToOpacity = tf->GetScalarOpacityFunction();
       m_ScalarsToOpacity->Register(0);
     }
     else
     {
       if (m_ScalarsToColors) m_ScalarsToColors->UnRegister(0);
       m_ScalarsToColors = this->GetVtkLUT(renderer);
       assert(m_ScalarsToColors);
       m_ScalarsToColors->Register(0);
 
       float opacity;
       node->GetOpacity(opacity, renderer);
       if (m_ScalarsToOpacity) m_ScalarsToOpacity->UnRegister(0);
       m_ScalarsToOpacity = vtkPiecewiseFunction::New();
       double range[2];
       m_VtkPointSet->GetScalarRange(range);
       m_ScalarsToOpacity->AddSegment(range[0], opacity, range[1], opacity);
     }
   }
 }
 
 void mitk::UnstructuredGridMapper2D::Paint( mitk::BaseRenderer* renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if(!visible) return;
 
   vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform();
   vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
 
-  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
+  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
 
   Point3D point;
   Vector3D normal;
 
   if(worldPlaneGeometry.IsNotNull())
   {
     // set up vtkPlane according to worldGeometry
     point=worldPlaneGeometry->GetOrigin();
     normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
     m_Plane->SetTransform((vtkAbstractTransform*)NULL);
   }
   else
   {
     //@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?
     return;
-    AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
+    AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldPlaneGeometry());
     if(worldAbstractGeometry.IsNotNull())
     {
       // set up vtkPlane according to worldGeometry
       point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
       FillVector3D(normal, 0, 0, 1);
       m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
     }
     else
       return;
   }
 
   double vp[ 3 ], vnormal[ 3 ];
 
   vnl2vtk(point.GetVnlVector(), vp);
   vnl2vtk(normal.GetVnlVector(), vnormal);
 
   //normally, we would need to transform the surface and cut the transformed surface with the cutter.
   //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
   //@todo It probably does not work for scaling operations yet:scaling operations have to be
   //dealed with after the cut is performed by scaling the contour.
   inversetransform->TransformPoint( vp, vp );
   inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );
 
   m_Plane->SetOrigin( vp );
   m_Plane->SetNormal( vnormal );
 
   // set data into cutter
   m_Slicer->SetInputData( m_VtkPointSet );
   //    m_Cutter->GenerateCutScalarsOff();
   //    m_Cutter->SetSortByToSortByCell();
 
   // calculate the cut
   m_Slicer->Update();
 
   // fetch geometry
   mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
   assert( displayGeometry );
   //  float toGL=displayGeometry->GetSizeInDisplayUnits()[1];
 
   //apply color and opacity read from the PropertyList
   ApplyColorAndOpacityProperties( renderer );
 
   // traverse the cut contour
   vtkPolyData * contour = m_Slicer->GetOutput();
 
   vtkPoints *vpoints = contour->GetPoints();
   vtkCellArray *vlines = contour->GetLines();
   vtkCellArray *vpolys = contour->GetPolys();
   vtkPointData *vpointdata = contour->GetPointData();
   vtkDataArray* vscalars = vpointdata->GetScalars();
 
   vtkCellData *vcelldata = contour->GetCellData();
   vtkDataArray* vcellscalars = vcelldata->GetScalars();
 
   const int numberOfLines = contour->GetNumberOfLines();
   const int numberOfPolys = contour->GetNumberOfPolys();
 
   const bool useCellData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT ||
       m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA;
   const bool usePointData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA;
 
   Point3D p;
   Point2D p2d;
 
   vlines->InitTraversal();
   vpolys->InitTraversal();
 
   mitk::Color outlineColor = m_Color->GetColor();
 
   glLineWidth((float)m_LineWidth->GetValue());
 
   for (int i = 0;i < numberOfLines;++i )
   {
     vtkIdType *cell(0);
     vtkIdType cellSize(0);
 
     vlines->GetNextCell( cellSize, cell );
 
     float rgba[4] = {outlineColor[0], outlineColor[1], outlineColor[2], 1.0f};
     if (m_ScalarVisibility->GetValue() && vcellscalars)
     {
       if ( useCellData )
       {  // color each cell according to cell data
         double scalar = vcellscalars->GetComponent( i, 0 );
         double rgb[3] = { 1.0f, 1.0f, 1.0f };
         m_ScalarsToColors->GetColor(scalar, rgb);
         rgba[0] = (float)rgb[0];
         rgba[1] = (float)rgb[1];
         rgba[2] = (float)rgb[2];
         rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
       }
       else if ( usePointData )
       {
         double scalar = vscalars->GetComponent( i, 0 );
         double rgb[3] = { 1.0f, 1.0f, 1.0f };
         m_ScalarsToColors->GetColor(scalar, rgb);
         rgba[0] = (float)rgb[0];
         rgba[1] = (float)rgb[1];
         rgba[2] = (float)rgb[2];
         rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
       }
     }
 
     glColor4fv( rgba );
 
     glBegin ( GL_LINE_LOOP );
     for ( int j = 0;j < cellSize;++j )
     {
       vpoints->GetPoint( cell[ j ], vp );
       //take transformation via vtktransform into account
       vtktransform->TransformPoint( vp, vp );
 
       vtk2itk( vp, p );
 
       //convert 3D point (in mm) to 2D point on slice (also in mm)
       worldGeometry->Map( p, p2d );
 
       //convert point (until now mm and in worldcoordinates) to display coordinates (units )
       displayGeometry->WorldToDisplay( p2d, p2d );
 
       //convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
       //p2d[1]=toGL-p2d[1];
 
       //add the current vertex to the line
       glVertex2f( p2d[0], p2d[1] );
     }
     glEnd ();
 
   }
 
   bool polyOutline = m_Outline->GetValue();
   bool scalarVisibility = m_ScalarVisibility->GetValue();
 
   // cache the transformed points
   // a fixed size array is way faster than 'new'
   // slices through 3d cells usually do not generated
   // polygons with more than 6 vertices
   const int maxPolySize = 10;
   Point2D* cachedPoints = new Point2D[maxPolySize*numberOfPolys];
 
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   // only draw polygons if there are cell scalars
   // or the outline property is set to true
   if (scalarVisibility && vcellscalars)
   {
     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
     for (int i = 0;i < numberOfPolys;++i )
     {
       vtkIdType *cell(0);
       vtkIdType cellSize(0);
 
       vpolys->GetNextCell( cellSize, cell );
 
       float rgba[4] = {1.0f, 1.0f, 1.0f, 0};
       if (scalarVisibility && vcellscalars)
       {
         if ( useCellData )
         {  // color each cell according to cell data
           double scalar = vcellscalars->GetComponent( i+numberOfLines, 0 );
           double rgb[3] = { 1.0f, 1.0f, 1.0f };
           m_ScalarsToColors->GetColor(scalar, rgb);
           rgba[0] = (float)rgb[0];
           rgba[1] = (float)rgb[1];
           rgba[2] = (float)rgb[2];
           rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
         }
         else if ( usePointData )
         {
           double scalar = vscalars->GetComponent( i, 0 );
           double rgb[3] = { 1.0f, 1.0f, 1.0f };
           m_ScalarsToColors->GetColor(scalar, rgb);
           rgba[0] = (float)rgb[0];
           rgba[1] = (float)rgb[1];
           rgba[2] = (float)rgb[2];
           rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
         }
       }
       glColor4fv( rgba );
 
       glBegin( GL_POLYGON );
       for (int j = 0; j < cellSize; ++j)
       {
         vpoints->GetPoint( cell[ j ], vp );
         //take transformation via vtktransform into account
         vtktransform->TransformPoint( vp, vp );
 
         vtk2itk( vp, p );
 
         //convert 3D point (in mm) to 2D point on slice (also in mm)
         worldGeometry->Map( p, p2d );
 
         //convert point (until now mm and in worldcoordinates) to display coordinates (units )
         displayGeometry->WorldToDisplay( p2d, p2d );
 
         //convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
         //p2d[1]=toGL-p2d[1];
 
         cachedPoints[i*10+j][0] = p2d[0];
         cachedPoints[i*10+j][1] = p2d[1];
 
         //add the current vertex to the line
         glVertex2f( p2d[0], p2d[1] );
       }
       glEnd();
     }
 
     if (polyOutline)
     {
       vpolys->InitTraversal();
 
       glColor4f(outlineColor[0], outlineColor[1], outlineColor[2], 1.0f);
       glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
       for (int i = 0;i < numberOfPolys;++i)
       {
         vtkIdType *cell(0);
         vtkIdType cellSize(0);
 
         vpolys->GetNextCell( cellSize, cell );
 
         glBegin( GL_POLYGON );
         //glPolygonOffset(1.0, 1.0);
         for (int j = 0; j < cellSize; ++j)
         {
           //add the current vertex to the line
           glVertex2f( cachedPoints[i*10+j][0], cachedPoints[i*10+j][1] );
         }
         glEnd();
       }
     }
   }
   glDisable(GL_BLEND);
   delete cachedPoints;
 }
 
 
 vtkAbstractMapper3D*
 mitk::UnstructuredGridMapper2D
 ::GetVtkAbstractMapper3D(mitk::BaseRenderer *  renderer)
 {
   //MITK_INFO << "GETVTKABSTRACTMAPPER3D\n";
   mitk::DataNode::ConstPointer node = this->GetDataNode();
   if ( node.IsNull() )
     return 0;
 
   mitk::VtkMapper::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper* > ( node->GetMapper( 2 ) );
   if ( mitkMapper.IsNull() )
   {
     return 0;
   }
 
   mitkMapper->Update(renderer);
 
   vtkAssembly* assembly = dynamic_cast<vtkAssembly*>(mitkMapper->GetVtkProp(renderer));
   if (assembly)
   {
     vtkProp3DCollection* collection = assembly->GetParts();
     collection->InitTraversal();
     vtkProp3D* prop3d = 0;
     do
     {
       prop3d = collection->GetNextProp3D();
       vtkActor* actor = dynamic_cast<vtkActor*>( prop3d );
       if (actor)
       {
         return dynamic_cast<vtkAbstractMapper3D*>( actor->GetMapper() );
       }
 
       vtkVolume* volume = dynamic_cast<vtkVolume*>( prop3d );
       if (volume)
       {
         return dynamic_cast<vtkAbstractMapper3D*>( volume->GetMapper() );
       }
     } while (prop3d != collection->GetLastProp3D());
   }
   else
   {
     vtkActor* actor = dynamic_cast<vtkActor*>( mitkMapper->GetVtkProp(renderer) );
     if (actor)
     {
       return dynamic_cast<vtkAbstractMapper3D*>( actor->GetMapper() );
     }
 
     vtkVolume* volume = dynamic_cast<vtkVolume*>( mitkMapper->GetVtkProp(renderer) );
     if (volume)
     {
       return dynamic_cast<vtkAbstractMapper3D*>( volume->GetMapper() );
     }
   }
   return 0;
 }
 
 
 
 vtkPointSet*
 mitk::UnstructuredGridMapper2D
 ::GetVtkPointSet(mitk::BaseRenderer* renderer)
 {
   //MITK_INFO << "GETVTKPOINTSET\n";
   vtkAbstractMapper3D * abstractMapper = GetVtkAbstractMapper3D(renderer);
   if ( abstractMapper == 0 )
   {
     // try to get data from the node
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     if ( node.IsNull() )
       return 0;
     mitk::BaseData::Pointer data = node->GetData();
     mitk::UnstructuredGrid::Pointer grid = dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer());
     if (!grid.IsNull())
       return static_cast<vtkPointSet*>(grid->GetVtkUnstructuredGrid());
 
     return 0;
   }
   else
   {
     vtkMapper* mapper = dynamic_cast<vtkMapper*>(abstractMapper);
     if (mapper)
     {
       return dynamic_cast<vtkPointSet*>(mapper->GetInput());
     }
     vtkAbstractVolumeMapper* volMapper = dynamic_cast<vtkAbstractVolumeMapper*>(abstractMapper);
     if (volMapper)
     {
       return dynamic_cast<vtkPointSet*>(volMapper->GetDataSetInput());
     }
   }
 
   return 0;
 }
 
 
 
 vtkScalarsToColors* mitk::UnstructuredGridMapper2D::GetVtkLUT(mitk::BaseRenderer* renderer)
 {
   //MITK_INFO << "GETVTKLUT\n";
   vtkMapper * mapper = dynamic_cast<vtkMapper*>(GetVtkAbstractMapper3D(renderer));
   if (mapper)
     return mapper->GetLookupTable();
   else
   {
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     if ( node.IsNull() )
       return 0;
 
     mitk::VtkMapper::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper* > ( node->GetMapper( 2 ) );
     if ( mitkMapper.IsNull() )
     {
       //MITK_INFO << "mitkMapper is null\n";
       return 0;
     }
 
     mitkMapper->Update(renderer);
 
     vtkVolume* volume = dynamic_cast<vtkVolume*>( mitkMapper->GetVtkProp(renderer) );
     if (volume)
     {
       //MITK_INFO << "found volume prop\n";
       return static_cast<vtkScalarsToColors*>(volume->GetProperty()->GetRGBTransferFunction());
     }
 
     vtkAssembly* assembly = dynamic_cast<vtkAssembly*>(mitkMapper->GetVtkProp(renderer));
     if (assembly)
     {
       //MITK_INFO << "found assembly prop\n";
       mitk::TransferFunctionProperty::Pointer transferFuncProp;
       node->GetProperty(transferFuncProp, "TransferFunction", 0);
       if (transferFuncProp.IsNotNull())
       {
         MITK_INFO << "return colortransferfunction\n";
         return static_cast<vtkScalarsToColors*>(transferFuncProp->GetValue()->GetColorTransferFunction());
       }
     }
     return 0;
   }
 }
 
 
 bool mitk::UnstructuredGridMapper2D::IsConvertibleToVtkPointSet(mitk::BaseRenderer * renderer)
 {
   return ( GetVtkPointSet(renderer) != 0 );
 }
 
 mitk::UnstructuredGridMapper2D::UnstructuredGridMapper2D()
 {
   m_Plane = vtkPlane::New();
   m_Slicer = vtkPointSetSlicer::New();
 
   m_Slicer->SetSlicePlane( m_Plane );
 
   m_ScalarsToColors = 0;
   m_ScalarsToOpacity = 0;
   m_VtkPointSet = 0;
 
   //m_LUT = vtkLookupTable::New();
   //m_LUT->SetTableRange( 0, 255 );
   //m_LUT->SetNumberOfColors( 255 );
   //m_LUT->SetRampToLinear ();
   //m_LUT->Build();
 }
 
 
 
 mitk::UnstructuredGridMapper2D::~UnstructuredGridMapper2D()
 {
   m_Slicer->Delete();
   m_Plane->Delete();
 
   if (m_ScalarsToOpacity != 0) m_ScalarsToOpacity->UnRegister(0);
   if (m_ScalarsToColors != 0) m_ScalarsToColors->UnRegister(0);
   if (m_VtkPointSet != 0) m_VtkPointSet->UnRegister(0);
 }
diff --git a/Modules/MapperExt/mitkVectorImageMapper2D.cpp b/Modules/MapperExt/mitkVectorImageMapper2D.cpp
index 272e17d85a..630e380897 100644
--- a/Modules/MapperExt/mitkVectorImageMapper2D.cpp
+++ b/Modules/MapperExt/mitkVectorImageMapper2D.cpp
@@ -1,538 +1,538 @@
 /*===================================================================
 
 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 "mitkVectorImageMapper2D.h"
 
 //vtk related includes
 #include <vtkPlane.h>
 #include <vtkLookupTable.h>
 #include <vtkScalarsToColors.h>
 #include <vtkImageReslice.h>
 #include <vtkPolyData.h>
 #include <vtkGlyph2D.h>
 #include <vtkGlyphSource2D.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkFloatArray.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkDataArray.h>
 #include <vtkMath.h>
 #include <vtkLinearTransform.h>
 #include <vtkMatrixToLinearTransform.h>
 #include <vtkLookupTable.h>
 #include <vtkScalarsToColors.h>
 #include <vtkTransform.h>
 #include <vtkImageData.h>
 #include <vtkDataSetWriter.h>
 #include <vtkMaskedGlyph3D.h>
 #include <vtkMaskedGlyph2D.h>
 #include <vtkMatrix4x4.h>
 #include <vtkCutter.h>
 #include <vtkPlane.h>
 #include <vtkIndent.h>
 #include <vtkDataObject.h>
 
 #include <fstream>
 
 //mitk related includes
 #include "mitkGL.h"
 #include "mitkBaseRenderer.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkAbstractTransformGeometry.h"
 #include <mitkLookupTableProperty.h>
 
 const mitk::Image * mitk::VectorImageMapper2D::GetInput( void )
 {
   if ( m_Image.IsNotNull() )
     return m_Image;
   else
     return dynamic_cast<const mitk::Image*>( GetDataNode()->GetData() );
 }
 
 
 void mitk::VectorImageMapper2D::Paint( mitk::BaseRenderer * renderer )
 {
   //std::cout << "2d vector mapping..." << std::endl;
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible )
     return ;
 
   mitk::Image::Pointer input = const_cast<mitk::Image*>( this->GetInput() );
 
   if ( input.IsNull() )
     return ;
 
 
-  mitk::PlaneGeometry::Pointer worldPlaneGeometry2D = dynamic_cast< mitk::PlaneGeometry*>( const_cast<mitk::PlaneGeometry*>( renderer->GetCurrentWorldGeometry2D() ) );
-  assert( worldPlaneGeometry2D.IsNotNull() );
+  mitk::PlaneGeometry::Pointer worldPlanePlaneGeometry = dynamic_cast< mitk::PlaneGeometry*>( const_cast<mitk::PlaneGeometry*>( renderer->GetCurrentWorldPlaneGeometry() ) );
+  assert( worldPlanePlaneGeometry.IsNotNull() );
 
   vtkImageData* vtkImage = input->GetVtkImageData( this->GetCurrentTimeStep( input, renderer ) );
 
   //
   // set up the cutter orientation according to the current geometry of
   // the renderers plane
   //
   Point3D point;
   Vector3D normal;
-  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
+  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
 
   if ( worldPlaneGeometry.IsNotNull() )
   {
     // set up vtkPlane according to worldGeometry
     point = worldPlaneGeometry->GetOrigin();
     normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
     m_Plane->SetTransform( (vtkAbstractTransform*)NULL );
   }
   else
   {
     itkWarningMacro( << "worldPlaneGeometry is NULL!" );
     return ;
   }
 
   double vp[ 3 ], vp_slice[ 3 ], vnormal[ 3 ];
   vnl2vtk( point.GetVnlVector(), vp );
   vnl2vtk( normal.GetVnlVector(), vnormal );
   //std::cout << "Origin: " << vp[0] <<" "<< vp[1] <<" "<< vp[2] << std::endl;
   //std::cout << "Normal: " << vnormal[0] <<" "<< vnormal[1] <<" "<< vnormal[2] << std::endl;
 
   //normally, we would need to transform the surface and cut the transformed surface with the cutter.
   //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
   //@todo It probably does not work for scaling operations yet:scaling operations have to be
   //dealed with after the cut is performed by scaling the contour.
   vtkLinearTransform * vtktransform = GetDataNode() ->GetVtkTransform();
 
   vtkTransform* world2vtk = vtkTransform::New();
   world2vtk->Identity();
   world2vtk->Concatenate(vtktransform->GetLinearInverse());
   double myscale[3];
   world2vtk->GetScale(myscale);
   world2vtk->PostMultiply();
   world2vtk->Scale(1/myscale[0],1/myscale[1],1/myscale[2]);
   world2vtk->TransformPoint( vp, vp );
   world2vtk->TransformNormalAtPoint( vp, vnormal, vnormal );
   world2vtk->Delete();
 
     // vtk works in axis align coords
   // thus the normal also must be axis align, since
   // we do not allow arbitrary cutting through volume
   //
   // vnormal should already be axis align, but in order
   // to get rid of precision effects, we set the two smaller
   // components to zero here
   int dims[3];
   vtkImage->GetDimensions(dims);
   double spac[3];
   vtkImage->GetSpacing(spac);
   vp_slice[0] = vp[0];
   vp_slice[1] = vp[1];
   vp_slice[2] = vp[2];
   if(fabs(vnormal[0]) > fabs(vnormal[1]) && fabs(vnormal[0]) > fabs(vnormal[2]) )
   {
     if(fabs(vp_slice[0]/spac[0]) < 0.4)
       vp_slice[0] = 0.4*spac[0];
     if(fabs(vp_slice[0]/spac[0]) > (dims[0]-1)-0.4)
       vp_slice[0] = ((dims[0]-1)-0.4)*spac[0];
     vnormal[1] = 0;
     vnormal[2] = 0;
   }
 
   if(fabs(vnormal[1]) > fabs(vnormal[0]) && fabs(vnormal[1]) > fabs(vnormal[2]) )
   {
     if(fabs(vp_slice[1]/spac[1]) < 0.4)
       vp_slice[1] = 0.4*spac[1];
     if(fabs(vp_slice[1]/spac[1]) > (dims[1]-1)-0.4)
       vp_slice[1] = ((dims[1]-1)-0.4)*spac[1];
     vnormal[0] = 0;
     vnormal[2] = 0;
   }
 
   if(fabs(vnormal[2]) > fabs(vnormal[1]) && fabs(vnormal[2]) > fabs(vnormal[0]) )
   {
     if(fabs(vp_slice[2]/spac[2]) < 0.4)
       vp_slice[2] = 0.4*spac[2];
     if(fabs(vp_slice[2]/spac[2]) > (dims[2]-1)-0.4)
       vp_slice[2] = ((dims[2]-1)-0.4)*spac[2];
     vnormal[0] = 0;
     vnormal[1] = 0;
   }
 
 
   m_Plane->SetOrigin( vp_slice );
   m_Plane->SetNormal( vnormal );
 
   vtkPolyData* cuttedPlane;
   if(!( (dims[0] == 1 && vnormal[0] != 0) ||
         (dims[1] == 1 && vnormal[1] != 0) ||
         (dims[2] == 1 && vnormal[2] != 0) ))
   {
     m_Cutter->SetCutFunction( m_Plane );
     m_Cutter->SetInputData( vtkImage );
     m_Cutter->GenerateCutScalarsOff();//!
     m_Cutter->Update();
     cuttedPlane = m_Cutter->GetOutput();
   }
   else
   {
     // cutting of a 2D-Volume does not work,
     // so we have to build up our own polydata object
     cuttedPlane = vtkPolyData::New();
     vtkPoints* points = vtkPoints::New();
     points->SetNumberOfPoints(vtkImage->GetNumberOfPoints());
     for(int i=0; i<vtkImage->GetNumberOfPoints(); i++)
       points->SetPoint(i, vtkImage->GetPoint(i));
     cuttedPlane->SetPoints(points);
     vtkFloatArray* pointdata = vtkFloatArray::New();
     int comps  = vtkImage->GetPointData()->GetScalars()->GetNumberOfComponents();
     pointdata->SetNumberOfComponents(comps);
     int tuples = vtkImage->GetPointData()->GetScalars()->GetNumberOfTuples();
     pointdata->SetNumberOfTuples(tuples);
     for(int i=0; i<tuples; i++)
       pointdata->SetTuple(i,vtkImage->GetPointData()->GetScalars()->GetTuple(i));
     pointdata->SetName( "vector" );
     cuttedPlane->GetPointData()->AddArray(pointdata);
   }
 
   if ( cuttedPlane->GetNumberOfPoints() != 0)
   {
     //
     // make sure, that we have point data with more than 1 component (as vectors)
     //
     vtkPointData * pointData = cuttedPlane->GetPointData();
     if ( pointData == NULL )
     {
       itkWarningMacro( << "no point data associated with cutters result!" );
       return ;
     }
     if ( pointData->GetNumberOfArrays() == 0 )
     {
       itkWarningMacro( << "point data returned by cutter doesn't have any arrays associated!" );
       return ;
     }
     else if ( pointData->GetArray(0)->GetNumberOfComponents() <= 1)
     {
       itkWarningMacro( << "number of components <= 1!" );
       return;
     }
     else if ( pointData->GetArrayName( 0 ) == NULL )
     {
       pointData->GetArray( 0 ) ->SetName( "vector" );
       //std::cout << "array name = vectors now" << std::endl;
     }
     //std::cout << "  projecting..."<< std::endl;
 
     //
     // constrain the vectors to lie on the plane, which means to remove the vector component,
     // which is orthogonal to the plane.
     //
     vtkIdType numPoints, pointId;
     numPoints = cuttedPlane->GetNumberOfPoints();
     vtkDataArray* inVectors = cuttedPlane->GetPointData()->GetVectors( "vector" );
     assert( inVectors != NULL );
     vtkFloatArray* vectorMagnitudes = vtkFloatArray::New();
     vectorMagnitudes->SetName("vectorMagnitudes");
     vectorMagnitudes->SetNumberOfComponents(1);
     vectorMagnitudes->SetNumberOfValues(numPoints);
     vectorMagnitudes->SetNumberOfTuples(numPoints);
     double inVector[ 3 ], outVector[3], wnormal[3]; //, tmpVector[ 3 ], outVector[ 3 ];
     double k = 0.0;
     vnl2vtk( normal.GetVnlVector(), wnormal );
     vtkMath::Normalize( wnormal );
     bool normalizeVecs;
     m_DataNode->GetBoolProperty( "NormalizeVecs", normalizeVecs );
     for ( pointId = 0; pointId < numPoints; ++pointId )
     {
       inVectors->GetTuple( pointId, inVector );
       if(normalizeVecs)
       {
         vnl_vector<double> tmp(3);
         vtk2vnl(inVector, tmp);
         tmp.normalize();
         vnl2vtk(tmp, inVector);
       }
       k = vtkMath::Dot( wnormal, inVector );
       // Remove non orthogonal component.
       outVector[ 0 ] = inVector[ 0 ] - ( wnormal[ 0 ] * k );
       outVector[ 1 ] = inVector[ 1 ] - ( wnormal[ 1 ] * k );
       outVector[ 2 ] = inVector[ 2 ] - ( wnormal[ 2 ] * k );
       inVectors->SetTuple( pointId, outVector );
 
       // ?? this was set to norm(inVector) before, but outVector made more sense to me
       vectorMagnitudes->SetValue( pointId, vtkMath::Norm( outVector ) );
 
 
       //std::cout << "method old: " << inVector[0] <<", " << inVector[1] << ", "<<inVector[2] << ", method new: " << outVector[0] << ", "<< outVector[1] << ", "<< outVector[2] << std::endl;
     }
     pointData->AddArray(vectorMagnitudes);
     pointData->CopyAllOn();
 
     //pointData->PrintSelf(std::cout, vtkIndent(4));
     //std::cout << "  ...done!"<< std::endl;
     //std::cout << "  glyphing..."<< std::endl;
 
     // call glyph2D to generate 2D glyphs for each of the
     // vectors
     vtkGlyphSource2D* glyphSource = vtkGlyphSource2D::New();
     //glyphSource->SetGlyphTypeToDash();
     glyphSource->DashOn();
     //glyphSource->SetScale( 0.1 );
     //glyphSource->SetScale2( .5 );
     //glyphSource->SetCenter( 0.5, 0.5, 0.5 );
     glyphSource->CrossOff();
     //glyphSource->FilledOff();
     //glyphSource->Update();
 
     double spacing[3];
     vtkImage->GetSpacing(spacing);
     double min = spacing[0];
     min = min > spacing[1] ? spacing[1] : min;
     min = min > spacing[2] ? spacing[2] : min;
 
     float scale = 1;
     mitk::FloatProperty::Pointer mitkScaleProp = dynamic_cast<mitk::FloatProperty*>(GetDataNode()->GetProperty("Scale"));
     if (mitkScaleProp.IsNotNull())
     {
       scale = mitkScaleProp->GetValue();
     }
 
     vtkMaskedGlyph3D* glyphGenerator = vtkMaskedGlyph3D::New();
     glyphGenerator->SetSourceData(glyphSource->GetOutput() );
     glyphGenerator->SetInput(cuttedPlane);
     glyphGenerator->SetInputArrayToProcess (1, 0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector");
     glyphGenerator->SetVectorModeToUseVector();
     glyphGenerator->OrientOn();
     glyphGenerator->SetScaleFactor( min*scale );
     glyphGenerator->SetUseMaskPoints( true );
     glyphGenerator->SetRandomMode( true );
     glyphGenerator->SetMaximumNumberOfPoints( 128*128 );
 
     glyphGenerator->Update();
 
     /*
     vtkLookupTable* vtkLut = NULL;
     mitk::LookupTableProperty::Pointer mitkLutProp = dynamic_cast<mitk::LookupTableProperty*>(GetDataNode()->GetProperty("LookupTable"));
     if (mitkLutProp.IsNotNull())
     {
       vtkLut = mitkLutProp->GetLookupTable()->GetVtkLookupTable();
     }
     */
 
     mitk::Color color;
     mitk::ColorProperty::Pointer mitkColorProp = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("color"));
     if (mitkColorProp.IsNotNull())
     {
       color = mitkColorProp->GetColor();
     }
     else
     {
       color.SetRed(0);
       color.SetBlue(1);
       color.SetGreen(0);
     }
 
     float lwidth = 1;
     mitk::FloatProperty::Pointer mitkLWidthProp = dynamic_cast<mitk::FloatProperty*>(GetDataNode()->GetProperty("LineWidth"));
     if (mitkLWidthProp.IsNotNull())
     {
       lwidth = mitkLWidthProp->GetValue();
     }
 
     vtkTransform* trafo = vtkTransform::New();
     trafo->Identity();
     trafo->Concatenate(vtktransform);
     trafo->PreMultiply();
     double myscale[3];
     trafo->GetScale(myscale);
     trafo->Scale(1/myscale[0],1/myscale[1],1/myscale[2]);
 
-    this->PaintCells( glyphGenerator->GetOutput(), renderer->GetCurrentWorldGeometry2D(), renderer->GetDisplayGeometry(), trafo, renderer, NULL/*vtkLut*/, color, lwidth, spacing );
+    this->PaintCells( glyphGenerator->GetOutput(), renderer->GetCurrentWorldPlaneGeometry(), renderer->GetDisplayGeometry(), trafo, renderer, NULL/*vtkLut*/, color, lwidth, spacing );
 
     vectorMagnitudes->Delete();
     glyphSource->Delete();
     glyphGenerator->Delete();
     trafo->Delete();
   }
   else
   {
     std::cout << "  no points cutted!"<< std::endl;
   }
   //std::cout << "...done!" << std::endl;
 }
 
 
 
 
 
 
 
 void mitk::VectorImageMapper2D::PaintCells( vtkPolyData* glyphs, const PlaneGeometry* worldGeometry, const DisplayGeometry* displayGeometry, vtkLinearTransform* vtktransform, mitk::BaseRenderer*  /*renderer*/, vtkScalarsToColors *lut, mitk::Color color, float lwidth, double *spacing )
 {
 
   vtkPoints * points = glyphs->GetPoints();
   vtkPointData * vpointdata = glyphs->GetPointData();
   vtkDataArray* vpointscalars = vpointdata->GetArray("vectorMagnitudes");
   //vtkDataArray* vpointpositions = vpointdata->GetArray("pointPositions");
   assert(vpointscalars != NULL);
   //std::cout << "  Scalars range 2d:" << vpointscalars->GetRange()[0] << " " << vpointscalars->GetRange()[0] << std::endl;
 
   Point3D p;
   Point2D p2d;
   vtkIdList* idList;
   vtkCell* cell;
 
   double offset[3];
   for (unsigned int i = 0; i < 3; ++i)
   {
     offset[i] = 0;
   }
 
   vtkIdType numCells = glyphs->GetNumberOfCells();
   for ( vtkIdType cellId = 0; cellId < numCells; ++cellId )
   {
     double vp[ 3 ];
 
     cell = glyphs->GetCell( cellId );
     idList = cell->GetPointIds();
 
     int numPoints = idList->GetNumberOfIds();
 
     if(numPoints == 1)
     {
       //take transformation via vtktransform into account
       double pos[ 3 ],vp_raster[3];
       points->GetPoint( idList->GetId( 0 ), vp );
       vp_raster[0] = vtkMath::Round(vp[0]/spacing[0])*spacing[0];
       vp_raster[1] = vtkMath::Round(vp[1]/spacing[1])*spacing[1];
       vp_raster[2] = vtkMath::Round(vp[2]/spacing[2])*spacing[2];
       vtktransform->TransformPoint( vp_raster, pos );
       offset[0] = pos[0] - vp[0];
       offset[1] = pos[1] - vp[1];
       offset[2] = pos[2] - vp[2];
     }
     else
     {
       glLineWidth(lwidth);
       glBegin ( GL_LINE_LOOP );
 
       for ( int pointNr = 0; pointNr < numPoints ;++pointNr )
       {
         points->GetPoint( idList->GetId( pointNr ), vp );
 
         vp[0] = vp[0] + offset[0];
         vp[1] = vp[1] + offset[1];
         vp[2] = vp[2] + offset[2];
 
         double tmp[ 3 ];
         vtktransform->TransformPoint( vp,tmp );
 
         vtk2itk( vp, p );
 
         //convert 3D point (in mm) to 2D point on slice (also in mm)
         worldGeometry->Map( p, p2d );
 
         //convert point (until now mm and in worldcoordinates) to display coordinates (units )
         displayGeometry->WorldToDisplay( p2d, p2d );
 
         if ( lut != NULL )
         {
           // color each point according to point data
           double * color;
 
           if ( vpointscalars != NULL )
           {
             vpointscalars->GetComponent( pointNr, 0 );
             color = lut->GetColor( vpointscalars->GetComponent( idList->GetId( pointNr ), 0 ) );
             glColor3f( color[ 0 ], color[ 1 ], color[ 2 ] );
           }
         }
         else
         {
           glColor3f( color.GetRed(), color.GetGreen(), color.GetBlue() );
         }
 
         //std::cout <<  idList->GetId( pointNr )<< ": " << p2d[0]<< " "<< p2d[1] << std::endl;
         //draw the line
         glVertex2f( p2d[ 0 ], p2d[ 1 ] );
 
 
 
       }
       glEnd ();
     }
   }
 }
 
 
 mitk::VectorImageMapper2D::VectorImageMapper2D()
 {
   m_LUT = NULL;
   m_Plane = vtkPlane::New();
   m_Cutter = vtkCutter::New();
 
   m_Cutter->SetCutFunction( m_Plane );
   m_Cutter->GenerateValues( 1, 0, 1 );
 }
 
 
 mitk::VectorImageMapper2D::~VectorImageMapper2D()
 {
   if ( m_LUT != NULL )
     m_LUT->Delete();
   if ( m_Plane != NULL )
     m_Plane->Delete();
   if ( m_Cutter != NULL )
     m_Cutter->Delete();
 }
 
 int mitk::VectorImageMapper2D::GetCurrentTimeStep( mitk::BaseData* data, mitk::BaseRenderer* renderer )
 {
   //
   // get the TimeGeometry of the input object
   //
   const TimeGeometry * dataTimeGeometry = data->GetUpdatedTimeGeometry();
   if ( ( dataTimeGeometry == NULL ) || ( dataTimeGeometry->CountTimeSteps() == 0 ) )
   {
     itkWarningMacro( << "The given object is missing a mitk::TimeGeometry, or the number of time steps is 0!" );
     return 0;
   }
 
   //
   // get the world time
   //
-  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
+  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   assert( worldGeometry.IsNotNull() );
   ScalarType time = worldGeometry->GetTimeBounds() [ 0 ];
 
   //
   // convert the world time to time steps of the input object
   //
   int timestep = 0;
   if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
     timestep = dataTimeGeometry->TimePointToTimeStep( time );
   if ( dataTimeGeometry->IsValidTimeStep( timestep ) == false )
   {
     itkWarningMacro( << timestep << " is not a valid time of the given data object!" );
     return 0;
   }
   return timestep;
 }
diff --git a/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp b/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp
index 9caec5b63e..f82d58edff 100644
--- a/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp
+++ b/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp
@@ -1,323 +1,323 @@
 /*===================================================================
 
 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 "mitkPlanarFigure.h"
 #include <mitkExtrudePlanarFigureFilter.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSurface.h>
 #include <vtkCellArray.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkPoints.h>
 #include <vtkSmartPointer.h>
 
 static mitk::Point2D GetCenterPoint(const mitk::PlanarFigure::PolyLineType& polyLine)
 {
   mitk::Point2D centerPoint;
 
   centerPoint[0] = 0;
   centerPoint[1] = 0;
 
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineEnd = polyLine.end();
 
   for (mitk::PlanarFigure::PolyLineType::const_iterator polyLineIter = polyLine.begin(); polyLineIter != polyLineEnd; ++polyLineIter)
   {
     centerPoint[0] += polyLineIter->Point[0];
     centerPoint[1] += polyLineIter->Point[1];
   }
 
   size_t numPoints = polyLine.size();
 
   centerPoint[0] /= numPoints;
   centerPoint[1] /= numPoints;
 
   return centerPoint;
 }
 
 static mitk::Point2D GetCenterPoint(mitk::PlanarFigure* planarFigure)
 {
   mitk::Point2D centerPoint;
 
   centerPoint[0] = 0;
   centerPoint[1] = 0;
 
   size_t numPolyLines = planarFigure->GetPolyLinesSize();
 
   for (size_t i = 0; i < numPolyLines; ++i)
   {
     mitk::Point2D polyLineCenterPoint = GetCenterPoint(planarFigure->GetPolyLine(i));
 
     centerPoint[0] += polyLineCenterPoint[0];
     centerPoint[1] += polyLineCenterPoint[1];
   }
 
   centerPoint[0] /= numPolyLines;
   centerPoint[1] /= numPolyLines;
 
   return centerPoint;
 }
 
 static mitk::Vector3D GetBendDirection(const mitk::PlaneGeometry* planeGeometry, const mitk::Point2D& centerPoint2d, const mitk::Vector2D& bendDirection2d)
 {
   mitk::Point2D point2d = centerPoint2d + bendDirection2d;
 
   mitk::Point3D point3d;
   planeGeometry->Map(point2d, point3d);
 
   mitk::Point3D centerPoint3d;
   planeGeometry->Map(centerPoint2d, centerPoint3d);
 
   mitk::Vector3D bendDirection3d = point3d - centerPoint3d;
   bendDirection3d.Normalize();
 
   return bendDirection3d;
 }
 
 mitk::ExtrudePlanarFigureFilter::ExtrudePlanarFigureFilter()
   : m_Length(1),
     m_NumberOfSegments(1),
     m_TwistAngle(0),
     m_BendAngle(0),
     m_FlipDirection(false),
     m_FlipNormals(false)
 {
   m_BendDirection[0] = 0;
   m_BendDirection[1] = 0;
 
   this->SetNumberOfRequiredInputs(1);
   this->SetNumberOfRequiredOutputs(1);
 
   this->SetNthOutput(0, this->MakeOutput(0));
 }
 
 mitk::ExtrudePlanarFigureFilter::~ExtrudePlanarFigureFilter()
 {
 }
 
 void mitk::ExtrudePlanarFigureFilter::GenerateData()
 {
   typedef PlanarFigure::PolyLineType PolyLine;
   typedef PolyLine::const_iterator PolyLineConstIter;
 
   if (m_Length <= 0)
     mitkThrow() << "Length is not positive!";
 
   if (m_NumberOfSegments == 0)
     mitkThrow() << "Number of segments is zero!";
 
   if (m_BendAngle != 0 && m_BendDirection[0] == 0 && m_BendDirection[1] == 0)
     mitkThrow() << "Bend direction is zero-length vector!";
 
   PlanarFigure* input = dynamic_cast<PlanarFigure*>(this->GetPrimaryInput());
 
   if (input == NULL)
     mitkThrow() << "Primary input is not a planar figure!";
 
   size_t numPolyLines = input->GetPolyLinesSize();
 
   if (numPolyLines == 0)
     mitkThrow() << "Primary input does not contain any poly lines!";
 
-  const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(input->GetGeometry2D());
+  const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(input->GetPlaneGeometry());
 
   if (planeGeometry == NULL)
     mitkThrow() << "Could not get plane geometry from primary input!";
 
   Vector3D planeNormal = planeGeometry->GetNormal();
   planeNormal.Normalize();
 
   Point2D centerPoint2d = GetCenterPoint(input);
 
   Point3D centerPoint3d;
   planeGeometry->Map(centerPoint2d, centerPoint3d);
 
   Vector3D bendDirection3d = m_BendAngle != 0
     ? ::GetBendDirection(planeGeometry, centerPoint2d, m_BendDirection)
     : Vector3D();
 
   ScalarType radius = m_Length * (360 / m_BendAngle) / (2 * vnl_math::pi);
   Vector3D scaledBendDirection3d = bendDirection3d * radius;
 
   Vector3D bendAxis = itk::CrossProduct(planeNormal, bendDirection3d);
   bendAxis.Normalize();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
   vtkIdType baseIndex = 0;
 
   for (size_t i = 0; i < numPolyLines; ++i)
   {
     PolyLine polyLine = input->GetPolyLine(i);
     size_t numPoints = polyLine.size();
 
     if (numPoints < 2)
       mitkThrow() << "Poly line " << i << " of primary input consists of less than two points!";
 
     std::vector<mitk::Point3D> crossSection;
 
     PolyLineConstIter polyLineEnd = polyLine.end();
 
     for (PolyLineConstIter polyLineIter = polyLine.begin(); polyLineIter != polyLineEnd; ++polyLineIter)
     {
       Point3D point;
       planeGeometry->Map(polyLineIter->Point, point);
       crossSection.push_back(point);
     }
 
     ScalarType segmentLength = m_Length / m_NumberOfSegments;
     Vector3D translation = planeNormal * segmentLength;
 
     bool bend = std::abs(m_BendAngle) > mitk::eps;
     bool twist = std::abs(m_TwistAngle) > mitk::eps;
 
     ScalarType twistAngle = twist
       ? m_TwistAngle / m_NumberOfSegments * vnl_math::pi / 180
       : 0;
 
     ScalarType bendAngle = bend
       ? m_BendAngle / m_NumberOfSegments * vnl_math::pi / 180
       : 0;
 
     if (m_FlipDirection)
     {
       translation *= -1;
       bendAngle *= -1;
     }
 
     for (size_t k = 0; k < numPoints; ++k)
       points->InsertNextPoint(crossSection[k].GetDataPointer());
 
     for (size_t j = 1; j <= m_NumberOfSegments; ++j)
     {
       mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
 
       if (bend || twist)
         transform->Translate(centerPoint3d.GetVectorFromOrigin(), true);
 
       if (bend)
       {
         transform->Translate(scaledBendDirection3d, true);
         transform->Rotate3D(bendAxis, bendAngle * j, true);
         transform->Translate(-scaledBendDirection3d, true);
       }
       else
       {
         transform->Translate(translation * j, true);
       }
 
       if (twist)
         transform->Rotate3D(planeNormal, twistAngle * j, true);
 
       if (bend || twist)
         transform->Translate(-centerPoint3d.GetVectorFromOrigin(), true);
 
       for (size_t k = 0; k < numPoints; ++k)
       {
         mitk::Point3D transformedPoint = transform->TransformPoint(crossSection[k]);
         points->InsertNextPoint(transformedPoint.GetDataPointer());
       }
     }
 
     for (size_t j = 0; j < m_NumberOfSegments; ++j)
     {
       for (size_t k = 1; k < numPoints; ++k)
       {
         vtkIdType cell[3];
         cell[0] = baseIndex + j * numPoints + (k - 1);
         cell[1] = baseIndex + (j + 1) * numPoints + (k - 1);
         cell[2] = baseIndex + j * numPoints + k;
 
         cells->InsertNextCell(3, cell);
 
         cell[0] = cell[1];
         cell[1] = baseIndex + (j + 1) * numPoints + k;
 
         cells->InsertNextCell(3, cell);
       }
 
       if (input->IsClosed() && numPoints > 2)
       {
         vtkIdType cell[3];
         cell[0] = baseIndex + j * numPoints + (numPoints - 1);
         cell[1] = baseIndex + (j + 1) * numPoints + (numPoints - 1);
         cell[2] = baseIndex + j * numPoints;
 
         cells->InsertNextCell(3, cell);
 
         cell[0] = cell[1];
         cell[1] = baseIndex + (j + 1) * numPoints;
 
         cells->InsertNextCell(3, cell);
       }
     }
 
     baseIndex += points->GetNumberOfPoints();
   }
 
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(points);
   polyData->SetPolys(cells);
 
   vtkSmartPointer<vtkPolyDataNormals> polyDataNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
   polyDataNormals->SetFlipNormals(m_FlipNormals);
   polyDataNormals->SetInputData(polyData);
   polyDataNormals->SplittingOff();
 
   polyDataNormals->Update();
 
   Surface* output = static_cast<Surface*>(this->GetPrimaryOutput());
   output->SetVtkPolyData(polyDataNormals->GetOutput());
 }
 
 void mitk::ExtrudePlanarFigureFilter::GenerateOutputInformation()
 {
 }
 
 itk::ProcessObject::DataObjectPointer mitk::ExtrudePlanarFigureFilter::MakeOutput(DataObjectPointerArraySizeType idx)
 {
   return idx == 0
     ? Surface::New().GetPointer()
     : NULL;
 }
 
 itk::ProcessObject::DataObjectPointer mitk::ExtrudePlanarFigureFilter::MakeOutput(const DataObjectIdentifierType& name)
 {
   return this->IsIndexedOutputName(name)
     ? this->MakeOutput(this->MakeIndexFromOutputName(name))
     : NULL;
 }
 
 void mitk::ExtrudePlanarFigureFilter::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 
   os << indent << "Length: " << m_Length << std::endl;
   os << indent << "Number of Segments: " << m_NumberOfSegments << std::endl;
   os << indent << "Twist Angle: " << m_TwistAngle << std::endl;
   os << indent << "Bend Angle: " << m_BendAngle << std::endl;
   os << indent << "Bend Direction: " << m_BendDirection << std::endl;
   os << indent << "Flip Normals: " << m_FlipNormals << std::endl;
 }
 
 void mitk::ExtrudePlanarFigureFilter::SetInput(PlanarFigure* planarFigure)
 {
   this->SetPrimaryInput(planarFigure);
 }
 
 mitk::Surface* mitk::ExtrudePlanarFigureFilter::GetOutput()
 {
   return static_cast<Surface*>(this->GetPrimaryOutput());
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp
index 2349939f66..10f53b994b 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp
@@ -1,165 +1,165 @@
 /*===================================================================
 
 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 "mitkPlanarCircle.h"
 #include "mitkPlaneGeometry.h"
 
 #include "mitkProperties.h"
 
 
 mitk::PlanarCircle::PlanarCircle()
 : FEATURE_ID_RADIUS( this->AddFeature( "Radius", "mm" ) ),
   FEATURE_ID_DIAMETER( this->AddFeature( "Diameter", "mm" ) ),
   FEATURE_ID_AREA( this->AddFeature( "Area", "mm2" ) ),
   m_MinRadius(0),
   m_MaxRadius(100),
   m_MinMaxRadiusContraintsActive(false)
 {
   // Circle has two control points
   this->ResetNumberOfControlPoints( 2 );
   this->SetNumberOfPolyLines( 1 );
   this->SetProperty( "closed", mitk::BoolProperty::New(true) );
 }
 
 
 mitk::PlanarCircle::~PlanarCircle()
 {
 }
 
 bool mitk::PlanarCircle::SetControlPoint( unsigned int index, const Point2D &point, bool /*createIfDoesNotExist*/ )
 {
   // moving center point
   if(index == 0)
   {
     const Point2D &centerPoint = GetControlPoint( 0 );
     Point2D boundaryPoint = GetControlPoint( 1 );
     vnl_vector<ScalarType> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
 
     boundaryPoint[0] += vec[0];
     boundaryPoint[1] += vec[1];
     PlanarFigure::SetControlPoint( 0, point );
     PlanarFigure::SetControlPoint( 1, boundaryPoint );
     return true;
   }
   else if ( index == 1 )
   {
     PlanarFigure::SetControlPoint( index, point );
     return true;
   }
   return false;
 }
 
 mitk::Point2D mitk::PlanarCircle::ApplyControlPointConstraints(unsigned int index, const Point2D &point)
 {
-  if ( this->GetGeometry2D() ==  NULL )
+  if ( this->GetPlaneGeometry() ==  NULL )
   {
     return point;
   }
 
   Point2D indexPoint;
-  this->GetGeometry2D()->WorldToIndex( point, indexPoint );
+  this->GetPlaneGeometry()->WorldToIndex( point, indexPoint );
 
-  BoundingBox::BoundsArrayType bounds = this->GetGeometry2D()->GetBounds();
+  BoundingBox::BoundsArrayType bounds = this->GetPlaneGeometry()->GetBounds();
   if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
   if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
   if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
   if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
   Point2D constrainedPoint;
-  this->GetGeometry2D()->IndexToWorld( indexPoint, constrainedPoint );
+  this->GetPlaneGeometry()->IndexToWorld( indexPoint, constrainedPoint );
 
   if(m_MinMaxRadiusContraintsActive)
   {
     if( index != 0)
     {
       const Point2D &centerPoint = this->GetControlPoint(0);
       double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point);
 
       Vector2D vectorProjectedPoint;
       vectorProjectedPoint = point - centerPoint;
       vectorProjectedPoint.Normalize();
 
       if( euclideanDinstanceFromCenterToPoint1 > m_MaxRadius )
       {
         vectorProjectedPoint *= m_MaxRadius;
         constrainedPoint = centerPoint;
         constrainedPoint += vectorProjectedPoint;
       }
       else if( euclideanDinstanceFromCenterToPoint1 < m_MinRadius )
       {
         vectorProjectedPoint *= m_MinRadius;
         constrainedPoint = centerPoint;
         constrainedPoint += vectorProjectedPoint;
       }
     }
   }
 
   return constrainedPoint;
 }
 
 void mitk::PlanarCircle::GeneratePolyLine()
 {
   // TODO: start circle at specified boundary point...
 
   // clear the PolyLine-Contrainer, it will be reconstructed soon enough...
   this->ClearPolyLines();
 
   const Point2D &centerPoint = GetControlPoint( 0 );
   const Point2D &boundaryPoint = GetControlPoint( 1 );
 
   double radius = centerPoint.EuclideanDistanceTo( boundaryPoint );
 
   // Generate poly-line with 64 segments
   for ( int t = 0; t < 64; ++t )
   {
     double alpha = (double) t * vnl_math::pi / 32.0;
 
     // construct the new polyline point ...
     Point2D polyLinePoint;
     polyLinePoint[0] = centerPoint[0] + radius * cos( alpha );
     polyLinePoint[1] = centerPoint[1] + radius * sin( alpha );
 
     // ... and append it to the PolyLine.
     // No extending supported here, so we can set the index of the PolyLineElement to '0'
     AppendPointToPolyLine( 0, PolyLineElement( polyLinePoint, 0 ) );
   }
 }
 
 void mitk::PlanarCircle::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A circle does not require a helper object
 }
 
 void mitk::PlanarCircle::EvaluateFeaturesInternal()
 {
   // Calculate circle radius and area
   const Point3D &p0 = this->GetWorldControlPoint( 0 );
   const Point3D &p1 = this->GetWorldControlPoint( 1 );
 
   double radius = p0.EuclideanDistanceTo( p1 );
   double area = vnl_math::pi * radius * radius;
 
   this->SetQuantity( FEATURE_ID_RADIUS, radius );
   this->SetQuantity( FEATURE_ID_DIAMETER, 2*radius );
   this->SetQuantity( FEATURE_ID_AREA, area );
 }
 
 
 void mitk::PlanarCircle::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
index 271f4f8f45..754529369c 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
@@ -1,275 +1,275 @@
 /*===================================================================
 
 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 <algorithm>
 
 #include "mitkPlanarEllipse.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 
 #include <algorithm>
 
 mitk::PlanarEllipse::PlanarEllipse()
     : m_MinRadius(0),
       m_MaxRadius(100),
       m_MinMaxRadiusContraintsActive(false),
       m_TreatAsCircle(true)
 {
     // Ellipse has three control points
     this->ResetNumberOfControlPoints( 4 );
     this->SetNumberOfPolyLines( 2 );
     this->SetProperty( "closed", mitk::BoolProperty::New(true) );
 }
 
 
 mitk::PlanarEllipse::~PlanarEllipse()
 {
 }
 
 bool mitk::PlanarEllipse::SetControlPoint( unsigned int index, const Point2D &point, bool createIfDoesNotExist )
 {
     if(index == 0) // moving center point and control points accordingly
     {
         const Point2D &centerPoint = GetControlPoint( 0 );
         Point2D boundaryPoint1 = GetControlPoint( 1 );
         Point2D boundaryPoint2 = GetControlPoint( 2 );
         Point2D boundaryPoint3 = GetControlPoint( 3 );
         vnl_vector<ScalarType> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
 
         boundaryPoint1[0] += vec[0];
         boundaryPoint1[1] += vec[1];
         boundaryPoint2[0] += vec[0];
         boundaryPoint2[1] += vec[1];
         boundaryPoint3[0] += vec[0];
         boundaryPoint3[1] += vec[1];
         PlanarFigure::SetControlPoint( 0, point, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 1, boundaryPoint1, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 2, boundaryPoint2, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 3, boundaryPoint3, createIfDoesNotExist );
         return true;
     }
     else if (index < 3)
     {
         PlanarFigure::SetControlPoint( index, point, createIfDoesNotExist );
         int otherIndex = index+1;
         if (otherIndex > 2)
             otherIndex = 1;
 
         const Point2D &centerPoint = GetControlPoint( 0 );
         Point2D otherPoint = GetControlPoint( otherIndex );
         Point2D point3 = GetControlPoint( 3 );
 
         Vector2D vec1 = point - centerPoint;
         Vector2D vec2;
 
         if (index == 1 && m_TreatAsCircle )
         {
             float x = vec1[0];
             vec2[0] = vec1[1];
             vec2[1] = x;
 
             if (index==1)
                 vec2[0] *= -1;
             else
                 vec2[1] *= -1;
 
             otherPoint = centerPoint+vec2;
             PlanarFigure::SetControlPoint( otherIndex, otherPoint, createIfDoesNotExist );
             float r = centerPoint.EuclideanDistanceTo(otherPoint);
 
             // adjust additional third control point
             Point2D p3 = this->GetControlPoint(3);
             Vector2D vec3;
             vec3[0] = p3[0]-centerPoint[0];
             vec3[1] = p3[1]-centerPoint[1];
             if (vec3[0]!=0 || vec3[1]!=0)
             {
                 vec3.Normalize();
                 vec3 *= r;
             }
             else
             {
                 vec3[0] = r;
                 vec3[1] = 0;
             }
             point3 = centerPoint + vec3;
             PlanarFigure::SetControlPoint( 3, point3, createIfDoesNotExist );
         }
         else if ( vec1.GetNorm() > 0 )
         {
             float r = centerPoint.EuclideanDistanceTo(otherPoint);
             float x = vec1[0];
             vec2[0] = vec1[1];
             vec2[1] = x;
 
             if (index==1)
                 vec2[0] *= -1;
             else
                 vec2[1] *= -1;
 
             vec2.Normalize(); vec2 *= r;
 
             if ( vec2.GetNorm() > 0 )
             {
                 otherPoint = centerPoint+vec2;
                 PlanarFigure::SetControlPoint( otherIndex, otherPoint, createIfDoesNotExist );
             }
 
             // adjust third control point
             Vector2D vec3 = point3 - centerPoint; vec3.Normalize();
             double r1 = centerPoint.EuclideanDistanceTo( GetControlPoint( 1 ) );
             double r2 = centerPoint.EuclideanDistanceTo( GetControlPoint( 2 ) );
             Point2D newPoint = centerPoint + vec3*std::max(r1, r2);
             PlanarFigure::SetControlPoint( 3, newPoint, createIfDoesNotExist );
 
             m_TreatAsCircle = false;
         }
         return true;
     }
     else if (index == 3)
     {
         Point2D centerPoint = GetControlPoint( 0 );
         Vector2D vec3 = point - centerPoint; vec3.Normalize();
         double r1 = centerPoint.EuclideanDistanceTo( GetControlPoint( 1 ) );
         double r2 = centerPoint.EuclideanDistanceTo( GetControlPoint( 2 ) );
         Point2D newPoint = centerPoint + vec3*std::max(r1, r2);
         PlanarFigure::SetControlPoint( index, newPoint, createIfDoesNotExist );
         m_TreatAsCircle = false;
         return true;
     }
     return false;
 }
 
 void mitk::PlanarEllipse::PlaceFigure( const mitk::Point2D &point )
 {
     PlanarFigure::PlaceFigure( point );
     m_SelectedControlPoint = 1;
 }
 
 mitk::Point2D mitk::PlanarEllipse::ApplyControlPointConstraints(unsigned int index, const Point2D &point)
 {
     return point;
 
     Point2D indexPoint;
-    this->GetGeometry2D()->WorldToIndex( point, indexPoint );
+    this->GetPlaneGeometry()->WorldToIndex( point, indexPoint );
 
-    BoundingBox::BoundsArrayType bounds = this->GetGeometry2D()->GetBounds();
+    BoundingBox::BoundsArrayType bounds = this->GetPlaneGeometry()->GetBounds();
     if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
     if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
     if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
     if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
     Point2D constrainedPoint;
-    this->GetGeometry2D()->IndexToWorld( indexPoint, constrainedPoint );
+    this->GetPlaneGeometry()->IndexToWorld( indexPoint, constrainedPoint );
 
     if(m_MinMaxRadiusContraintsActive)
     {
         if( index != 0)
         {
             const Point2D &centerPoint = this->GetControlPoint(0);
             double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point);
 
             Vector2D vectorProjectedPoint;
             vectorProjectedPoint = point - centerPoint;
             vectorProjectedPoint.Normalize();
 
             if( euclideanDinstanceFromCenterToPoint1 > m_MaxRadius )
             {
                 vectorProjectedPoint *= m_MaxRadius;
                 constrainedPoint = centerPoint;
                 constrainedPoint += vectorProjectedPoint;
             }
             else if( euclideanDinstanceFromCenterToPoint1 < m_MinRadius )
             {
                 vectorProjectedPoint *= m_MinRadius;
                 constrainedPoint = centerPoint;
                 constrainedPoint += vectorProjectedPoint;
             }
         }
     }
 
     return constrainedPoint;
 }
 
 void mitk::PlanarEllipse::GeneratePolyLine()
 {
     // clear the PolyLine-Contrainer, it will be reconstructed soon enough...
     this->ClearPolyLines();
 
     const Point2D &centerPoint = GetControlPoint( 0 );
     const Point2D &boundaryPoint1 = GetControlPoint( 1 );
     const Point2D &boundaryPoint2 = GetControlPoint( 2 );
 
     Vector2D dir = boundaryPoint1 - centerPoint; dir.Normalize();
     vnl_matrix_fixed<float, 2, 2> rot;
 
     // differentiate between clockwise and counterclockwise rotation
     int start = 0;
     int end = 64;
     if (dir[1]<0)
     {
         dir[0] = -dir[0];
         start = -32;
         end = 32;
     }
     // construct rotation matrix to align ellipse with control point vector
     rot[0][0] = dir[0];
     rot[1][1] = rot[0][0];
     rot[1][0] = sin(acos(rot[0][0]));
     rot[0][1] = -rot[1][0];
 
     double radius1 = centerPoint.EuclideanDistanceTo( boundaryPoint1 );
     double radius2 = centerPoint.EuclideanDistanceTo( boundaryPoint2 );
 
     // Generate poly-line with 64 segments
     for ( int t = start; t < end; ++t )
     {
         double alpha = (double) t * vnl_math::pi / 32.0;
 
         // construct the new polyline point ...
         vnl_vector_fixed< float, 2 > vec;
         vec[0] = radius1 * cos( alpha );
         vec[1] = radius2 * sin( alpha );
         vec = rot*vec;
 
         Point2D polyLinePoint;
         polyLinePoint[0] = centerPoint[0] + vec[0];
         polyLinePoint[1] = centerPoint[1] + vec[1];
 
         // ... and append it to the PolyLine.
         // No extending supported here, so we can set the index of the PolyLineElement to '0'
         AppendPointToPolyLine( 0, PolyLineElement( polyLinePoint, 0 ) );
     }
 
     AppendPointToPolyLine( 1, PolyLineElement( centerPoint, 0 ) );
     AppendPointToPolyLine( 1, PolyLineElement( GetControlPoint( 3 ), 0 ) );
 }
 
 void mitk::PlanarEllipse::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
     // A circle does not require a helper object
 }
 
 void mitk::PlanarEllipse::EvaluateFeaturesInternal()
 {
 
 }
 
 
 void mitk::PlanarEllipse::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
     Superclass::PrintSelf( os, indent );
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
index 4b01db1661..4d1d0ac0f0 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
@@ -1,730 +1,730 @@
 /*===================================================================
 
 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 "mitkPlanarFigure.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 #include <mitkProportionalTimeGeometry.h>
 
 #include "algorithm"
 
 
 mitk::PlanarFigure::PlanarFigure()
 : m_SelectedControlPoint( -1 ),
   m_PreviewControlPointVisible( false ),
   m_FigurePlaced( false ),
-  m_Geometry2D( NULL ),
+  m_PlaneGeometry( NULL ),
   m_PolyLineUpToDate(false),
   m_HelperLinesUpToDate(false),
   m_FeaturesUpToDate(false),
   m_FeaturesMTime( 0 )
 {
 
 
   m_HelperPolyLinesToBePainted = BoolContainerType::New();
 
   m_DisplaySize.first = 0.0;
   m_DisplaySize.second = 0;
 
   this->SetProperty( "closed", mitk::BoolProperty::New( false ) );
 
   // Currently only single-time-step geometries are supported
   this->InitializeTimeGeometry( 1 );
 }
 
 
 mitk::PlanarFigure::~PlanarFigure()
 {
 }
 
 
 mitk::PlanarFigure::PlanarFigure(const Self& other)
   : BaseData(other),
     m_ControlPoints(other.m_ControlPoints),
     m_NumberOfControlPoints(other.m_NumberOfControlPoints),
     m_SelectedControlPoint(other.m_SelectedControlPoint),
     m_PolyLines(other.m_PolyLines),
     m_HelperPolyLines(other.m_HelperPolyLines),
     m_HelperPolyLinesToBePainted(other.m_HelperPolyLinesToBePainted->Clone()),
     m_PreviewControlPoint(other.m_PreviewControlPoint),
     m_PreviewControlPointVisible(other.m_PreviewControlPointVisible),
     m_FigurePlaced(other.m_FigurePlaced),
-    m_Geometry2D(other.m_Geometry2D), // do not clone since SetGeometry2D() doesn't clone either
+    m_PlaneGeometry(other.m_PlaneGeometry), // do not clone since SetPlaneGeometry() doesn't clone either
     m_PolyLineUpToDate(other.m_PolyLineUpToDate),
     m_HelperLinesUpToDate(other.m_HelperLinesUpToDate),
     m_FeaturesUpToDate(other.m_FeaturesUpToDate),
     m_Features(other.m_Features),
     m_FeaturesMTime(other.m_FeaturesMTime),
     m_DisplaySize(other.m_DisplaySize)
 {
 }
 
 
-void mitk::PlanarFigure::SetGeometry2D( mitk::PlaneGeometry *geometry )
+void mitk::PlanarFigure::SetPlaneGeometry( mitk::PlaneGeometry *geometry )
 {
   this->SetGeometry( geometry );
-  m_Geometry2D = dynamic_cast<PlaneGeometry *>(GetGeometry(0));//geometry;
+  m_PlaneGeometry = dynamic_cast<PlaneGeometry *>(GetGeometry(0));//geometry;
 }
 
 
-const mitk::PlaneGeometry *mitk::PlanarFigure::GetGeometry2D() const
+const mitk::PlaneGeometry *mitk::PlanarFigure::GetPlaneGeometry() const
 {
-  return m_Geometry2D;
+  return m_PlaneGeometry;
 }
 
 
 bool mitk::PlanarFigure::IsClosed() const
 {
   mitk::BoolProperty* closed = dynamic_cast< mitk::BoolProperty* >( this->GetProperty( "closed" ).GetPointer() );
   if ( closed != NULL )
   {
     return closed->GetValue();
   }
   return false;
 }
 
 
 void mitk::PlanarFigure::PlaceFigure( const mitk::Point2D& point )
 {
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     m_ControlPoints.push_back( this->ApplyControlPointConstraints( i, point ) );
   }
 
   m_FigurePlaced = true;
   m_SelectedControlPoint = 1;
 }
 
 
 bool mitk::PlanarFigure::AddControlPoint( const mitk::Point2D& point, int position )
 {
   // if we already have the maximum number of control points, do nothing
   if ( m_NumberOfControlPoints < this->GetMaximumNumberOfControlPoints() )
   {
     // if position has not been defined or position would be the last control point, just append the new one
     // we also append a new point if we click onto the line between the first two control-points if the second control-point is selected
     // -> special case for PlanarCross
     if ( position == -1 || position > (int)m_NumberOfControlPoints-1 || (position == 1 && m_SelectedControlPoint == 2) )
     {
       if ( m_ControlPoints.size() > this->GetMaximumNumberOfControlPoints()-1 )
       {
         // get rid of deprecated control points in the list. This is necessary
         // as ::ResetNumberOfControlPoints() only sets the member, does not resize the list!
         m_ControlPoints.resize( this->GetNumberOfControlPoints() );
       }
 
       m_ControlPoints.push_back( this->ApplyControlPointConstraints( m_NumberOfControlPoints, point ) );
       m_SelectedControlPoint = m_NumberOfControlPoints;
     }
     else
     {
       // insert the point at the given position and set it as selected point
       ControlPointListType::iterator iter = m_ControlPoints.begin() + position;
       m_ControlPoints.insert( iter, this->ApplyControlPointConstraints( position, point ) );
       for( unsigned int i = 0; i < m_ControlPoints.size(); ++i )
       {
         if( point == m_ControlPoints.at(i) )
         {
           m_SelectedControlPoint = i;
         }
       }
     }
 
     // polylines & helperpolylines need to be repainted
     m_PolyLineUpToDate = false;
     m_HelperLinesUpToDate = false;
     m_FeaturesUpToDate = false;
 
     // one control point more
     ++m_NumberOfControlPoints;
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 bool mitk::PlanarFigure::SetControlPoint( unsigned int index, const Point2D& point, bool createIfDoesNotExist )
 {
   bool controlPointSetCorrectly = false;
   if (createIfDoesNotExist)
   {
     if ( m_NumberOfControlPoints <= index )
     {
       m_ControlPoints.push_back( this->ApplyControlPointConstraints( index, point ) );
       m_NumberOfControlPoints++;
     }
     else
     {
       m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
     }
     controlPointSetCorrectly = true;
   }
   else if ( index < m_NumberOfControlPoints )
   {
     m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
     controlPointSetCorrectly = true;
   }
   else
   {
     return false;
   }
 
   if ( controlPointSetCorrectly )
   {
     m_PolyLineUpToDate = false;
     m_HelperLinesUpToDate = false;
     m_FeaturesUpToDate = false;
   }
 
   return controlPointSetCorrectly;
 }
 
 
 bool mitk::PlanarFigure::SetCurrentControlPoint( const Point2D& point )
 {
   if ( (m_SelectedControlPoint < 0) || (m_SelectedControlPoint >= (int)m_NumberOfControlPoints) )
   {
     return false;
   }
 
   return this->SetControlPoint(m_SelectedControlPoint, point, false);
 }
 
 
 unsigned int mitk::PlanarFigure::GetNumberOfControlPoints() const
 {
   return m_NumberOfControlPoints;
 }
 
 
 bool mitk::PlanarFigure::SelectControlPoint( unsigned int index )
 {
   if ( index < this->GetNumberOfControlPoints() )
   {
     m_SelectedControlPoint = index;
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 bool mitk::PlanarFigure::DeselectControlPoint()
 {
   bool wasSelected = ( m_SelectedControlPoint != -1);
 
   m_SelectedControlPoint = -1;
 
   return wasSelected;
 }
 
 void mitk::PlanarFigure::SetPreviewControlPoint( const Point2D& point )
 {
   m_PreviewControlPoint = point;
   m_PreviewControlPointVisible = true;
 }
 
 void mitk::PlanarFigure::ResetPreviewContolPoint()
 {
   m_PreviewControlPointVisible = false;
 }
 
 mitk::Point2D mitk::PlanarFigure::GetPreviewControlPoint()
 {
   return m_PreviewControlPoint;
 }
 
 bool mitk::PlanarFigure::IsPreviewControlPointVisible()
 {
   return m_PreviewControlPointVisible;
 }
 
 mitk::Point2D mitk::PlanarFigure::GetControlPoint( unsigned int index ) const
 {
   if ( index < m_NumberOfControlPoints )
   {
     return m_ControlPoints.at( index );
   }
 
   itkExceptionMacro( << "GetControlPoint(): Invalid index!" );
 }
 
 
 mitk::Point3D mitk::PlanarFigure::GetWorldControlPoint( unsigned int index ) const
 {
   Point3D point3D;
-  if ( (m_Geometry2D != NULL) && (index < m_NumberOfControlPoints) )
+  if ( (m_PlaneGeometry != NULL) && (index < m_NumberOfControlPoints) )
   {
-    m_Geometry2D->Map( m_ControlPoints.at( index ), point3D );
+    m_PlaneGeometry->Map( m_ControlPoints.at( index ), point3D );
     return point3D;
   }
 
   itkExceptionMacro( << "GetWorldControlPoint(): Invalid index!" );
 }
 
 
 const mitk::PlanarFigure::PolyLineType
 mitk::PlanarFigure::GetPolyLine(unsigned int index)
 {
   mitk::PlanarFigure::PolyLineType polyLine;
   if ( index > m_PolyLines.size() || !m_PolyLineUpToDate )
     {
       this->GeneratePolyLine();
       m_PolyLineUpToDate = true;
     }
 
   return m_PolyLines.at( index );;
 }
 
 
 const mitk::PlanarFigure::PolyLineType
 mitk::PlanarFigure::GetPolyLine(unsigned int index) const
 {
   return m_PolyLines.at( index );
 }
 
 void mitk::PlanarFigure::ClearPolyLines()
 {
   for ( std::vector<PolyLineType>::size_type i=0; i<m_PolyLines.size(); i++ )
   {
     m_PolyLines.at( i ).clear();
   }
   m_PolyLineUpToDate = false;
 }
 
 const mitk::PlanarFigure::PolyLineType mitk::PlanarFigure::GetHelperPolyLine( unsigned int index,
                                                                              double mmPerDisplayUnit,
                                                                              unsigned int displayHeight )
 {
   mitk::PlanarFigure::PolyLineType helperPolyLine;
   if ( index < m_HelperPolyLines.size() )
   {
     // m_HelperLinesUpToDate does not cover changes in zoom-level, so we have to check previous values of the
     // two parameters as well
     if ( !m_HelperLinesUpToDate || m_DisplaySize.first != mmPerDisplayUnit || m_DisplaySize.second != displayHeight )
     {
       this->GenerateHelperPolyLine(mmPerDisplayUnit, displayHeight);
       m_HelperLinesUpToDate = true;
 
       // store these parameters to be able to check next time if somebody zoomed in or out
       m_DisplaySize.first = mmPerDisplayUnit;
       m_DisplaySize.second = displayHeight;
     }
 
     helperPolyLine = m_HelperPolyLines.at(index);
   }
 
   return helperPolyLine;
 }
 
 void mitk::PlanarFigure::ClearHelperPolyLines()
 {
   for ( std::vector<PolyLineType>::size_type i=0; i<m_HelperPolyLines.size(); i++ )
   {
     m_HelperPolyLines.at(i).clear();
   }
   m_HelperLinesUpToDate = false;
 }
 
 /** \brief Returns the number of features available for this PlanarFigure
 * (such as, radius, area, ...). */
 unsigned int mitk::PlanarFigure::GetNumberOfFeatures() const
 {
   return m_Features.size();
 }
 
 
 const char *mitk::PlanarFigure::GetFeatureName( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Name.c_str();
   }
   else
   {
     return NULL;
   }
 }
 
 
 const char *mitk::PlanarFigure::GetFeatureUnit( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Unit.c_str();
   }
   else
   {
     return NULL;
   }
 }
 
 
 double mitk::PlanarFigure::GetQuantity( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Quantity;
   }
   else
   {
     return 0.0;
   }
 }
 
 
 bool mitk::PlanarFigure::IsFeatureActive( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Active;
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::PlanarFigure::IsFeatureVisible( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Visible;
   }
   else
   {
     return false;
   }
 }
 
 void mitk::PlanarFigure::SetFeatureVisible( unsigned int index, bool visible )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Visible = visible;
   }
 }
 
 
 void mitk::PlanarFigure::EvaluateFeatures()
 {
   if ( !m_FeaturesUpToDate || !m_PolyLineUpToDate )
   {
     if ( !m_PolyLineUpToDate )
     {
       this->GeneratePolyLine();
     }
 
     this->EvaluateFeaturesInternal();
 
     m_FeaturesUpToDate = true;
   }
 }
 
 
 void mitk::PlanarFigure::UpdateOutputInformation()
 {
   // Bounds are NOT calculated here, since the PlaneGeometry defines a fixed
   // frame (= bounds) for the planar figure.
   Superclass::UpdateOutputInformation();
   this->GetTimeGeometry()->Update();
 }
 
 
 void mitk::PlanarFigure::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 
 bool mitk::PlanarFigure::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 
 bool mitk::PlanarFigure::VerifyRequestedRegion()
 {
   return true;
 }
 
 
 void mitk::PlanarFigure::SetRequestedRegion(const itk::DataObject * /*data*/ )
 {
 
 }
 
 
 void mitk::PlanarFigure::ResetNumberOfControlPoints( int numberOfControlPoints )
 {
   // DO NOT resize the list here, will cause crash!!
   m_NumberOfControlPoints = numberOfControlPoints;
 }
 
 
 mitk::Point2D mitk::PlanarFigure::ApplyControlPointConstraints( unsigned int /*index*/, const Point2D& point )
 {
-  if ( m_Geometry2D ==  NULL )
+  if ( m_PlaneGeometry ==  NULL )
   {
     return point;
   }
 
   Point2D indexPoint;
-  m_Geometry2D->WorldToIndex( point, indexPoint );
+  m_PlaneGeometry->WorldToIndex( point, indexPoint );
 
-  BoundingBox::BoundsArrayType bounds = m_Geometry2D->GetBounds();
+  BoundingBox::BoundsArrayType bounds = m_PlaneGeometry->GetBounds();
   if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
   if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
   if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
   if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
   Point2D constrainedPoint;
-  m_Geometry2D->IndexToWorld( indexPoint, constrainedPoint );
+  m_PlaneGeometry->IndexToWorld( indexPoint, constrainedPoint );
 
   return constrainedPoint;
 }
 
 
 unsigned int mitk::PlanarFigure::AddFeature( const char *featureName, const char *unitName )
 {
   unsigned int index = m_Features.size();
 
   Feature newFeature( featureName, unitName );
   m_Features.push_back( newFeature );
 
   return index;
 }
 
 
 void mitk::PlanarFigure::SetFeatureName( unsigned int index, const char *featureName )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Name = featureName;
   }
 }
 
 
 void mitk::PlanarFigure::SetFeatureUnit( unsigned int index, const char *unitName )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Unit = unitName;
   }
 }
 
 
 void mitk::PlanarFigure::SetQuantity( unsigned int index, double quantity )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Quantity = quantity;
   }
 }
 
 
 void mitk::PlanarFigure::ActivateFeature( unsigned int index )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Active = true;
   }
 }
 
 
 void mitk::PlanarFigure::DeactivateFeature( unsigned int index )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Active = false;
   }
 }
 
 void mitk::PlanarFigure::InitializeTimeGeometry( unsigned int timeSteps )
 {
   mitk::PlaneGeometry::Pointer geometry2D = mitk::PlaneGeometry::New();
   geometry2D->Initialize();
 
   if ( timeSteps > 1 )
   {
     mitk::ScalarType timeBounds[] = {0.0, 1.0};
     geometry2D->SetTimeBounds( timeBounds );
   }
 
   // The geometry is propagated automatically to all time steps,
   // if EvenlyTimed is true...
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(geometry2D, timeSteps);
   SetTimeGeometry(timeGeometry);
 }
 
 
 void mitk::PlanarFigure::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
   os << indent << this->GetNameOfClass() << ":\n";
 
   if (this->IsClosed())
     os << indent << "This figure is closed\n";
   else
     os << indent << "This figure is not closed\n";
   os << indent << "Minimum number of control points: " << this->GetMinimumNumberOfControlPoints() << std::endl;
   os << indent << "Maximum number of control points: " << this->GetMaximumNumberOfControlPoints() << std::endl;
   os << indent << "Current number of control points: " << this->GetNumberOfControlPoints() << std::endl;
   os << indent << "Control points:" << std::endl;
 
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     //os << indent.GetNextIndent() << i << ": " << m_ControlPoints->ElementAt( i ) << std::endl;
     os << indent.GetNextIndent() << i << ": " << m_ControlPoints.at( i ) << std::endl;
   }
   os << indent << "Geometry:\n";
-  this->GetGeometry2D()->Print(os, indent.GetNextIndent());
+  this->GetPlaneGeometry()->Print(os, indent.GetNextIndent());
 }
 
 
 unsigned short mitk::PlanarFigure::GetPolyLinesSize()
 {
   if ( !m_PolyLineUpToDate )
   {
     this->GeneratePolyLine();
     m_PolyLineUpToDate = true;
   }
   return m_PolyLines.size();
 }
 
 
 unsigned short mitk::PlanarFigure::GetHelperPolyLinesSize()
 {
   return m_HelperPolyLines.size();
 }
 
 
 bool mitk::PlanarFigure::IsHelperToBePainted(unsigned int index)
 {
   return m_HelperPolyLinesToBePainted->GetElement( index );
 }
 
 
 bool mitk::PlanarFigure::ResetOnPointSelect()
 {
   return false;
 }
 
 void mitk::PlanarFigure::RemoveControlPoint( unsigned int index )
 {
   if ( index > m_ControlPoints.size() )
     return;
 
   if ( (m_ControlPoints.size() -1)  < this->GetMinimumNumberOfControlPoints() )
     return;
 
   ControlPointListType::iterator iter;
   iter = m_ControlPoints.begin() + index;
 
   m_ControlPoints.erase( iter );
 
   m_PolyLineUpToDate = false;
   m_HelperLinesUpToDate = false;
   m_FeaturesUpToDate = false;
 
   --m_NumberOfControlPoints;
 }
 
 void mitk::PlanarFigure::RemoveLastControlPoint()
 {
   RemoveControlPoint( m_ControlPoints.size()-1 );
 }
 
 void mitk::PlanarFigure::DeepCopy(Self::Pointer oldFigure)
 {
   //DeepCopy only same types of planar figures
   //Notice to get typeid polymorph you have to use the *operator
   if(typeid(*oldFigure) != typeid(*this))
   {
     itkExceptionMacro( << "DeepCopy(): Inconsistent type of source (" << typeid(*oldFigure).name() << ") and destination figure (" << typeid(*this).name() << ")!" );
     return;
   }
 
   m_ControlPoints.clear();
   this->ClearPolyLines();
   this->ClearHelperPolyLines();
 
   // clone base data members
   SetPropertyList(oldFigure->GetPropertyList()->Clone());
 
   /// deep copy members
   m_FigurePlaced                = oldFigure->m_FigurePlaced;
   m_SelectedControlPoint        = oldFigure->m_SelectedControlPoint;
   m_FeaturesMTime               = oldFigure->m_FeaturesMTime;
   m_Features                    = oldFigure->m_Features;
   m_NumberOfControlPoints       = oldFigure->m_NumberOfControlPoints;
 
   //copy geometry 2D of planar figure
-  PlaneGeometry::Pointer affineGeometry = oldFigure->m_Geometry2D->Clone();
-  SetGeometry2D(affineGeometry.GetPointer());
+  PlaneGeometry::Pointer affineGeometry = oldFigure->m_PlaneGeometry->Clone();
+  SetPlaneGeometry(affineGeometry.GetPointer());
 
   for(unsigned long index=0; index < oldFigure->GetNumberOfControlPoints(); index++)
   {
     m_ControlPoints.push_back( oldFigure->GetControlPoint( index ));
   }
 
   //After setting the control points we can generate the polylines
   this->GeneratePolyLine();
 }
 
 void mitk::PlanarFigure::SetNumberOfPolyLines( unsigned int numberOfPolyLines )
 {
   m_PolyLines.resize(numberOfPolyLines);
 }
 
 void mitk::PlanarFigure::SetNumberOfHelperPolyLines( unsigned int numberOfHerlperPolyLines )
 {
   m_HelperPolyLines.resize(numberOfHerlperPolyLines);
 }
 
 
 void mitk::PlanarFigure::AppendPointToPolyLine( unsigned int index, PolyLineElement element )
 {
   if ( index < m_PolyLines.size() )
   {
     m_PolyLines.at( index ).push_back( element );
     m_PolyLineUpToDate = false;
   }
   else
   {
     MITK_ERROR << "Tried to add point to PolyLine " << index+1 << ", although only " << m_PolyLines.size() << " exists";
   }
 }
 
 void mitk::PlanarFigure::AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element )
 {
   if ( index < m_HelperPolyLines.size() )
   {
     m_HelperPolyLines.at( index ).push_back( element );
     m_HelperLinesUpToDate = false;
   }
   else
   {
     MITK_ERROR << "Tried to add point to HelperPolyLine " << index+1 << ", although only " << m_HelperPolyLines.size() << " exists";
   }
 }
 
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
index 5d5dca93c3..136a763159 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
@@ -1,418 +1,418 @@
 /*===================================================================
 
 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_PLANAR_FIGURE_H_
 #define _MITK_PLANAR_FIGURE_H_
 
 #include <MitkPlanarFigureExports.h>
 #include "mitkBaseData.h"
 #include "mitkCommon.h"
 
 #include <deque>
 
 
 namespace mitk
 {
 
 class PlaneGeometry;
 
 /**
  * \brief Base-class for geometric planar (2D) figures, such as
  * lines, circles, rectangles, polygons, etc.
  *
  * \warning Currently does not support time-resolved data handling
  *
  * Behavior and appearance of PlanarFigures are controlled by various properties; for a detailed
  * list of appearance properties see mitk::PlanarFigureMapper2D
  *
  * The following properties control general PlanarFigure behavior:
  *
  * <ul>
  *   <li>"selected": true if the planar figure is selected
  *   <li>"planarfigure.ishovering": true if the mouse "hovers" over the planar figure
  *   <li>"planarfigure.iseditable": true if the planar figure can be edited (otherwise,
  *       it can only be picked/selected, but its control points cannot be edited); default is true
  *   <li>"planarfigure.isextendable": true if new control points can be inserted into the list of control points;
  *        default is false
  * </ul>
  *
  *
  * TODO: Implement local 2D transform (including center of rotation...)
  *
  */
 class MitkPlanarFigure_EXPORT PlanarFigure : public BaseData
 {
 public:
   mitkClassMacro( PlanarFigure, BaseData )
   itkCloneMacro( Self )
 
   struct PolyLineElement
   {
     PolyLineElement( Point2D point, int index )
       : Point( point ), Index( index )
     {
     };
 
     Point2D Point;
     int Index;
   };
 
   typedef itk::VectorContainer< unsigned long, bool>  BoolContainerType;
 
   typedef std::deque< Point2D > ControlPointListType;
   typedef std::list< PolyLineElement > PolyLineType;
 
 
   /** \brief Sets the 2D geometry on which this figure will be placed.
    *
    * In most cases, this is a Geometry already owned by another object, e.g.
    * describing the slice of the image on which measurements will be
    * performed.
    */
-  virtual void SetGeometry2D( mitk::PlaneGeometry *geometry );
+  virtual void SetPlaneGeometry( mitk::PlaneGeometry *geometry );
 
 
   /** \brief Returns (previously set) 2D geometry of this figure. */
-  virtual const PlaneGeometry *GetGeometry2D() const;
+  virtual const PlaneGeometry *GetPlaneGeometry() const;
 
 
   /** \brief True if the planar figure is closed.
    *
    * Default is false. The "closed" boolean property must be set in sub-classes. */
   virtual bool IsClosed() const;
 
 
   /** \brief True if the planar figure has been placed (and can be
    * displayed/interacted with). */
   virtual bool IsPlaced() const { return m_FigurePlaced; };
 
 
   /** \brief Place figure at the given point (in 2D index coordinates) onto
    * the given 2D geometry.
    *
    * By default, the first two control points of the figure are set to the
    * passed point. Further points can be set via AddControlPoint(), if the
    * current number of control points is below the maximum number of control
    * points.
    *
    * Can be re-implemented in sub-classes as needed.
    */
   virtual void PlaceFigure( const Point2D& point );
 
   /**
   * \brief Adds / inserts new control-points
   *
   * This method adds a new control-point with the coordinates defined by point at the given index.
   * If 'index' == -1 or index is greater than the number of control-points the new point is appended
   * to the back of the list of control points.
   * If a control-point already exists for 'index', an additional point is inserted at that position.
   * It is not possible to add more points if the maximum number of control-points (GetMaximumNumberOfControlPoints())
   * has been reached.
   */
   virtual bool AddControlPoint( const Point2D& point, int index = -1 );
 
   virtual bool SetControlPoint( unsigned int index, const Point2D& point, bool createIfDoesNotExist = false);
 
   virtual bool SetCurrentControlPoint( const Point2D& point );
 
 
   /** \brief Returns the current number of 2D control points defining this figure. */
   unsigned int GetNumberOfControlPoints() const;
 
 
   /** \brief Returns the minimum number of control points needed to represent
    * this figure.
    *
    * Must be implemented in sub-classes.
    */
   virtual unsigned int GetMinimumNumberOfControlPoints() const = 0;
 
 
   /** \brief Returns the maximum number of control points allowed for
   * this figure (e.g. 3 for triangles).
   *
   * Must be implemented in sub-classes.
   */
   virtual unsigned int GetMaximumNumberOfControlPoints() const = 0;
 
 
   /** \brief Selects currently active control points. */
   virtual bool SelectControlPoint( unsigned int index );
 
 
   /** \brief Deselect control point; no control point active. */
   virtual bool DeselectControlPoint();
 
 
   /** \brief Return currently selected control point. */
   virtual int GetSelectedControlPoint() const { return m_SelectedControlPoint; }
 
   /** \brief Returns specified control point in 2D world coordinates. */
   Point2D GetControlPoint( unsigned int index ) const;
 
 
   /** \brief Returns specified control point in world coordinates. */
   Point3D GetWorldControlPoint( unsigned int index ) const;
 
 
   /** \brief Returns the polyline representing the planar figure
    * (for rendering, measurements, etc.). */
   const PolyLineType GetPolyLine(unsigned int index);
 
   /** \brief Returns the polyline representing the planar figure
    * (for rendering, measurments, etc.). */
   const PolyLineType GetPolyLine(unsigned int index) const;
 
   /** \brief Returns the polyline that should be drawn the same size at every scale
    * (for text, angles, etc.). */
   const PolyLineType GetHelperPolyLine( unsigned int index, double mmPerDisplayUnit, unsigned int displayHeight );
 
 
   /** \brief Sets the position of the PreviewControlPoint. Automatically sets it visible.*/
   void SetPreviewControlPoint( const Point2D& point );
 
   /** \brief Marks the PreviewControlPoint as invisible.*/
   void ResetPreviewContolPoint();
 
   /** \brief Returns whether or not the PreviewControlPoint is visible.*/
   bool IsPreviewControlPointVisible();
 
   /** \brief Returns the coordinates of the PreviewControlPoint. */
   Point2D GetPreviewControlPoint();
 
 
 
   /** \brief Returns the number of features available for this PlanarFigure
    * (such as, radius, area, ...). */
   virtual unsigned int GetNumberOfFeatures() const;
 
 
   /** \brief Returns the name (identifier) of the specified features. */
   const char *GetFeatureName( unsigned int index ) const;
 
 
   /** \brief Returns the physical unit of the specified features. */
   const char *GetFeatureUnit( unsigned int index ) const;
 
 
   /** Returns quantity of the specified feature (e.g., length, radius,
    * area, ... ) */
   double GetQuantity( unsigned int index ) const;
 
 
   /** \brief Returns true if the feature with the specified index exists and
   * is active (an inactive feature may e.g. be the area of a non-closed
   * polygon. */
   bool IsFeatureActive( unsigned int index ) const;
 
   /** \brief Returns true if the feature with the specified index exists and is set visible */
   bool IsFeatureVisible( unsigned int index ) const;
 
   /** \brief Defines if the feature with the specified index will be shown as an
   * overlay in the RenderWindow */
   void SetFeatureVisible( unsigned int index, bool visible );
 
 
   /** \brief Calculates quantities of all features of this planar figure. */
   virtual void EvaluateFeatures();
 
 
   /** \brief Intherited from parent */
   virtual void UpdateOutputInformation();
 
   /** \brief Intherited from parent */
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   /** \brief Intherited from parent */
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   /** \brief Intherited from parent */
   virtual bool VerifyRequestedRegion();
 
   /** \brief Intherited from parent */
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
   /** \brief  Returns the current number of polylines  */
   virtual unsigned short GetPolyLinesSize();
 
   /** \brief  Returns the current number of helperpolylines  */
   virtual unsigned short GetHelperPolyLinesSize();
 
   /** \brief Returns whether a helper polyline should be painted or not */
   virtual bool IsHelperToBePainted(unsigned int index);
 
   /** \brief Returns true if the planar figure is reset to "add points" mode
    * when a point is selected.
    *
    * Default return value is false. Subclasses can overwrite this method and
    * execute any reset / initialization statements required. */
   virtual bool ResetOnPointSelect();
 
   /** \brief removes the point with the given index from the list of controlpoints. */
   virtual void RemoveControlPoint( unsigned int index );
 
   /** \brief Removes last control point */
   virtual void RemoveLastControlPoint();
 
   /** \brief Copies contents and state of a figre provided as parameter to the current object.
     *
     * Requires a matching type of both figures.
     *
     * \note Deprecated, use Clone() instead.
     */
   DEPRECATED(void DeepCopy(Self::Pointer oldFigure));
 
   /** \brief Allow sub-classes to apply constraints on control points.
   *
   * Sub-classes can define spatial constraints to certain control points by
   * overwriting this method and returning a constrained point. By default,
   * the points are constrained by the image bounds. */
   virtual Point2D ApplyControlPointConstraints( unsigned int /*index*/, const Point2D& point );
 
 
 
 protected:
   PlanarFigure();
   virtual ~PlanarFigure();
 
   PlanarFigure(const Self& other);
 
   /** \brief Set the initial number of control points of the planar figure */
   void ResetNumberOfControlPoints( int numberOfControlPoints );
 
   /** Adds feature (e.g., circumference, radius, angle, ...) to feature vector
    * of a planar figure object and returns integer ID for the feature element.
    * Should be called in sub-class constructors. */
   virtual unsigned int AddFeature( const char *featureName, const char *unitName );
 
   /** Sets the name of the specified feature. INTERNAL METHOD. */
   void SetFeatureName( unsigned int index, const char *featureName );
 
   /** Sets the physical unit of the specified feature. INTERNAL METHOD. */
   void SetFeatureUnit( unsigned int index, const char *unitName );
 
   /** Sets quantity of the specified feature. INTERNAL METHOD. */
   void SetQuantity( unsigned int index, double quantity );
 
   /** Sets the specified feature as active. INTERAL METHOD. */
   void ActivateFeature( unsigned int index );
 
   /** Sets the specified feature as active. INTERAL METHOD. */
   void DeactivateFeature( unsigned int index );
 
   /** \brief Generates the poly-line representation of the planar figure.
    * Must be implemented in sub-classes. */
   virtual void GeneratePolyLine() = 0;
 
     /** \brief Generates the poly-lines that should be drawn the same size regardless of zoom.
    * Must be implemented in sub-classes. */
   virtual void GenerateHelperPolyLine(double mmPerDisplayUnit, unsigned int displayHeight) = 0;
 
   /** \brief Calculates quantities of all features of this planar figure.
    * Must be implemented in sub-classes. */
   virtual void EvaluateFeaturesInternal() = 0;
 
   /** \brief Initializes the TimeGeometry describing the (time-resolved)
    * geometry of this figure. Note that each time step holds one PlaneGeometry.
    */
   virtual void InitializeTimeGeometry( unsigned int timeSteps = 1 );
 
   /** \brief defines the number of PolyLines that will be available */
   void SetNumberOfPolyLines( unsigned int numberOfPolyLines );
 
   /** \brief Append a point to the PolyLine # index */
   void AppendPointToPolyLine( unsigned int index, PolyLineElement element );
 
   /** \brief clears the list of PolyLines. Call before re-calculating a new Polyline. */
   void ClearPolyLines();
 
 
   /** \brief defines the number of HelperPolyLines that will be available */
   void SetNumberOfHelperPolyLines( unsigned int numberOfHelperPolyLines );
 
   /** \brief Append a point to the HelperPolyLine # index */
   void AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element );
 
   /** \brief clears the list of HelperPolyLines. Call before re-calculating a new HelperPolyline. */
   void ClearHelperPolyLines();
 
   virtual void PrintSelf( std::ostream& os, itk::Indent indent ) const;
 
   ControlPointListType m_ControlPoints;
   unsigned int m_NumberOfControlPoints;
 
   // Currently selected control point; -1 means no point selected
   int m_SelectedControlPoint;
 
 
   std::vector<PolyLineType> m_PolyLines;
   std::vector<PolyLineType> m_HelperPolyLines;
   BoolContainerType::Pointer m_HelperPolyLinesToBePainted;
 
   // this point is used to store the coordiantes an additional 'ControlPoint' that is rendered
   // when the mouse cursor is above the figure (and not a control-point) and when the
   // property 'planarfigure.isextendable' is set to true
   Point2D m_PreviewControlPoint;
   bool m_PreviewControlPointVisible;
 
   bool m_FigurePlaced;
 
 private:
 
   // not implemented to prevent PlanarFigure::New() calls which would create an itk::Object.
   static Pointer New();
 
   struct Feature
   {
     Feature( const char *name, const char *unit )
     : Name( name ), Unit( unit ), Quantity( 0.0 ), Active( true ), Visible( true )
     {
     }
 
     std::string Name;
     std::string Unit;
     double Quantity;
     bool Active;
     bool Visible;
   };
 
   virtual itk::LightObject::Pointer InternalClone() const = 0;
 
-  PlaneGeometry *m_Geometry2D;
+  PlaneGeometry *m_PlaneGeometry;
 
 
   bool m_PolyLineUpToDate;
   bool m_HelperLinesUpToDate;
   bool m_FeaturesUpToDate;
 
 
   // Vector of features available for this geometric figure
   typedef std::vector< Feature > FeatureVectorType;
   FeatureVectorType m_Features;
 
   unsigned long m_FeaturesMTime;
 
   // this pair is used to store the mmInDisplayUnits (m_DisplaySize.first) and the displayHeight (m_DisplaySize.second)
   // that the helperPolyLines have been calculated for.
   // It's used to determine whether or not GetHelperPolyLine() needs to recalculate the HelperPolyLines.
   std::pair<double, unsigned int> m_DisplaySize;
 
 };
 
 } // namespace mitk
 
 #endif //_MITK_PLANAR_FIGURE_H_
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp
index 0c5719b211..2bf8caee31 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp
@@ -1,284 +1,284 @@
 /*===================================================================
 
 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 "mitkPlanarPolygon.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 
 // stl related includes
 #include <algorithm>
 
 
 mitk::PlanarPolygon::PlanarPolygon()
 : FEATURE_ID_CIRCUMFERENCE( this->AddFeature( "Circumference", "mm" ) ),
   FEATURE_ID_AREA( this->AddFeature( "Area", "mm2" ) )
 {
   // Polygon has at least two control points
   this->ResetNumberOfControlPoints( 2 );
   this->SetNumberOfPolyLines( 1 );
 
   // Polygon is closed by default
   this->SetProperty( "closed", mitk::BoolProperty::New( true ) );
   this->SetProperty( "subdivision", mitk::BoolProperty::New( false ) );
 }
 
 
 mitk::PlanarPolygon::~PlanarPolygon()
 {
 }
 
 
 void mitk::PlanarPolygon::SetClosed( bool closed )
 {
   this->SetProperty( "closed", mitk::BoolProperty::New( closed ) );
 
   if ( !closed )
   {
     // For non-closed polygons: use "Length" as feature name; disable area
     this->SetFeatureName( FEATURE_ID_CIRCUMFERENCE, "Length" );
     this->DeactivateFeature( FEATURE_ID_AREA );
   }
   else
   {
     // For closed polygons: use "Circumference" as feature name; enable area
     this->SetFeatureName( FEATURE_ID_CIRCUMFERENCE, "Circumference" );
     this->ActivateFeature( FEATURE_ID_AREA );
   }
 
   this->Modified();
 }
 
 
 void mitk::PlanarPolygon::GeneratePolyLine()
 {
   this->ClearPolyLines();
 
   for ( ControlPointListType::size_type i=0; i<m_ControlPoints.size(); i++ )
   {
     Point2D pnt = m_ControlPoints.at( i );
     PolyLineElement elem(pnt,i);
     this->AppendPointToPolyLine( 0, elem );
   }
 }
 
 void mitk::PlanarPolygon::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A polygon does not require helper objects
 }
 
 void mitk::PlanarPolygon::EvaluateFeaturesInternal()
 {
   // Calculate circumference
   double circumference = 0.0;
   unsigned int i,j;
 
   ControlPointListType polyLinePoints;
   polyLinePoints.clear();
   PolyLineType::iterator iter;
   for( iter = m_PolyLines[0].begin(); iter != m_PolyLines[0].end(); ++iter )
   {
     polyLinePoints.push_back((*iter).Point);
   }
 
   if(polyLinePoints.empty())
     return;
 
   for ( i = 0; i <(polyLinePoints.size()-1); ++i )
   {
     circumference += polyLinePoints[i].EuclideanDistanceTo(
       polyLinePoints[i + 1] );
   }
 
   if ( this->IsClosed() )
   {
     circumference += polyLinePoints[i].EuclideanDistanceTo(
       polyLinePoints.front() );
   }
 
   this->SetQuantity( FEATURE_ID_CIRCUMFERENCE, circumference );
 
 
   // Calculate polygon area (if closed)
   double area       = 0.0;
   bool intersection = false;
 
-  if ( this->IsClosed() && (this->GetGeometry2D() != NULL) )
+  if ( this->IsClosed() && (this->GetPlaneGeometry() != NULL) )
   {
     // does PlanarPolygon overlap/intersect itself?
     unsigned int numberOfPoints = polyLinePoints.size();
     if( numberOfPoints >= 4)
     {
       for ( i = 0; i < (numberOfPoints - 1); ++i )
       {
         // line 1
         Point2D p0 = polyLinePoints[i];
         Point2D p1 = polyLinePoints[i + 1];
 
         // check for intersection with all other lines
         for (j = i+1; j < (numberOfPoints - 1); ++j )
         {
           Point2D p2 = polyLinePoints[j];
           Point2D p3 = polyLinePoints[j + 1];
           intersection = CheckForLineIntersection(p0,p1,p2,p3);
           if (intersection) break;
         }
         if (intersection) break; // only because the inner loop might have changed "intersection"
 
         // last line from p_x to p_0
         Point2D p2 = polyLinePoints.front();
         Point2D p3 = polyLinePoints.back();
 
         intersection = CheckForLineIntersection(p0,p1,p2,p3);
         if (intersection) break;
       }
    }
 
     // calculate area
     for ( i = 0; i < polyLinePoints.size(); ++i )
     {
       Point2D p0 = polyLinePoints[i];
       Point2D p1 = polyLinePoints[ (i + 1) % polyLinePoints.size() ];
 
       area += p0[0] * p1[1] - p1[0] * p0[1];
     }
     area /= 2.0;
   }
 
   // set area if appropiate (i.e. closed and not intersected)
   if(this->IsClosed() && !intersection)
   {
     SetQuantity( FEATURE_ID_AREA, fabs( area ) );
     this->ActivateFeature( FEATURE_ID_AREA );
   }
   else
   {
     SetQuantity( FEATURE_ID_AREA,  0  );
     this->DeactivateFeature( FEATURE_ID_AREA );
   }
 }
 
 
 void mitk::PlanarPolygon::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 
   if (this->IsClosed())
     os << indent << "Polygon is closed\n";
   else
     os << indent << "Polygon is not closed\n";
 }
 
 // based on
 // http://flassari.is/2008/11/line-line-intersection-in-cplusplus/
 bool mitk::PlanarPolygon::CheckForLineIntersection( const mitk::Point2D& p1, const mitk::Point2D& p2, const mitk::Point2D& p3, const mitk::Point2D& p4, Point2D& intersection ) const
 {
   // do not check for intersections with control points
   if(p1 == p2 || p1 == p3 || p1 == p4 ||
      p2 == p3 || p2 == p4 ||
      p3 == p4)
     return false;
 
 
   // Store the values for fast access and easy
   // equations-to-code conversion
   double x1 = p1[0], x2 = p2[0], x3 = p3[0], x4 = p4[0];
   double y1 = p1[1], y2 = p2[1], y3 = p3[1], y4 = p4[1];
 
   double d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
   // If d is zero, there is no intersection
   //if (d < mitk::eps) return false;
   if (d == 0) return false;
 
   // Get the x and y
   double pre = (x1*y2 - y1*x2);
   double post = (x3*y4 - y3*x4);
   double x = ( pre * (x3 - x4) - (x1 - x2) * post ) / d;
   double y = ( pre * (y3 - y4) - (y1 - y2) * post ) / d;
 
   double tolerance = 0.001;
   // Check if the x coordinates are within both lines, including tolerance
   if ( x < ( std::min(x1, x2) - tolerance )
     || x > ( std::max(x1, x2) + tolerance )
     || x < ( std::min(x3, x4) - tolerance )
     || x > ( std::max(x3, x4) + tolerance )
     )
   {
     return false;
   }
 
   // Check if the y coordinates are within both lines, including tolerance
   if ( y < ( std::min(y1, y2) - tolerance )
     || y > ( std::max(y1, y2) + tolerance )
     || y < ( std::min(y3, y4) - tolerance )
     || y > ( std::max(y3, y4) + tolerance )
     )
   {
     return false;
   }
 
   // point of intersection
   Point2D ret; ret[0] = x; ret[1] = y;
   intersection = ret;
   return true;
 }
 
 bool mitk::PlanarPolygon::CheckForLineIntersection( const mitk::Point2D& p1, const mitk::Point2D& p2, const mitk::Point2D& p3, const mitk::Point2D& p4 ) const
 {
   mitk::Point2D intersection;
   return mitk::PlanarPolygon::CheckForLineIntersection( p1, p2, p3, p4, intersection );
 
 }
 
 std::vector<mitk::Point2D> mitk::PlanarPolygon::CheckForLineIntersection( const mitk::Point2D& p1, const mitk::Point2D& p2 ) const
 {
   std::vector<mitk::Point2D> intersectionList;
 
   ControlPointListType polyLinePoints;
   PolyLineType tempList = m_PolyLines[0];
   PolyLineType::iterator iter;
   for( iter = tempList.begin(); iter != tempList.end(); ++iter )
   {
     polyLinePoints.push_back((*iter).Point);
   }
 
   for ( ControlPointListType::size_type i=0; i<polyLinePoints.size()-1; i++ )
   {
     mitk::Point2D pnt1 = polyLinePoints[i];
     mitk::Point2D pnt2 = polyLinePoints[i+1];
     mitk::Point2D intersection;
 
     if ( mitk::PlanarPolygon::CheckForLineIntersection( p1, p2, pnt1, pnt2, intersection ) )
     {
       intersectionList.push_back( intersection );
     }
   }
 
   if ( this->IsClosed() )
   {
     mitk::Point2D intersection, lastControlPoint, firstControlPoint;
     lastControlPoint = polyLinePoints.back();
     firstControlPoint = polyLinePoints.front();
 
     if ( mitk::PlanarPolygon::CheckForLineIntersection( lastControlPoint,
       firstControlPoint, p1, p2, intersection ) )
     {
       intersectionList.push_back( intersection );
     }
   }
 
   return intersectionList;
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp
index 7bd8c378e2..19c6f5de43 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp
@@ -1,150 +1,150 @@
 /*===================================================================
 
 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 "mitkProperties.h"
 
 #include "mitkPlanarRectangle.h"
 #include "mitkPlaneGeometry.h"
 
 
 mitk::PlanarRectangle::PlanarRectangle()
 : FEATURE_ID_CIRCUMFERENCE( this->AddFeature( "Circumference", "mm" ) ),
   FEATURE_ID_AREA( this->AddFeature( "Area", "mm2" ) )
 {
   // Rectangle has four control points
   this->ResetNumberOfControlPoints( 4 );
   this->SetProperty( "closed", mitk::BoolProperty::New(true) );
   this->SetNumberOfPolyLines( 1 );
 }
 
 
 mitk::PlanarRectangle::~PlanarRectangle()
 {
 }
 
 
 bool mitk::PlanarRectangle::SetControlPoint( unsigned int index, const Point2D &point, bool createIfDoesNotExist )
 {
   // heres the deal with the rectangle:
   // when a point is moved all corresponding corner points are moved with him
   // e.g. if the lower right point (index=3) is moved the upper right point (index=1)
   // is moved in the same x direction
   // and the lower left point (index=2) is moved in the same y direction
   // the upper left point (index=0) is left untouched
   bool set = PlanarFigure::SetControlPoint( index, point, createIfDoesNotExist );
 
   if(set)
   {
     // can be made better ...
     unsigned int horizontalCorrespondingPointIndex = 1;
     unsigned int verticalCorrespondingPointIndex = 3;
     if(index == 1)
     {
       horizontalCorrespondingPointIndex = 0;
       verticalCorrespondingPointIndex = 2;
     }
     else if(index == 2)
     {
       horizontalCorrespondingPointIndex = 3;
       verticalCorrespondingPointIndex = 1;
     }
     else if(index == 3)
     {
       horizontalCorrespondingPointIndex = 2;
       verticalCorrespondingPointIndex = 0;
     }
 
     Point2D verticalCorrespondingPoint = GetControlPoint( verticalCorrespondingPointIndex );
     verticalCorrespondingPoint[0] = point[0];
     PlanarFigure::SetControlPoint( verticalCorrespondingPointIndex, verticalCorrespondingPoint );
 
     Point2D horizontalCorrespondingPoint = GetControlPoint( horizontalCorrespondingPointIndex );
     horizontalCorrespondingPoint[1] = point[1];
     PlanarFigure::SetControlPoint( horizontalCorrespondingPointIndex, horizontalCorrespondingPoint );
   }
 
   return set;
 }
 
 void mitk::PlanarRectangle::PlaceFigure( const mitk::Point2D &point )
 {
   PlanarFigure::PlaceFigure( point );
   m_SelectedControlPoint = 3;
 }
 
 void mitk::PlanarRectangle::GeneratePolyLine()
 {
   // TODO: start polygon at specified initalize point...
 
   ClearPolyLines();
 
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     AppendPointToPolyLine( 0, PolyLineElement( GetControlPoint(i), i ) );
   }
 }
 
 void mitk::PlanarRectangle::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A polygon does not require helper objects
 }
 
 void mitk::PlanarRectangle::EvaluateFeaturesInternal()
 {
   // Calculate circumference
   double circumference = 0.0;
   unsigned int i;
   for ( i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     circumference += this->GetWorldControlPoint( i ).EuclideanDistanceTo(
       this->GetWorldControlPoint( (i + 1) % this->GetNumberOfControlPoints() ) );
   }
 
   this->SetQuantity( FEATURE_ID_CIRCUMFERENCE, circumference );
 
 
   // Calculate rectangle area (well, done a bit clumsy...)
   double area = 0.0;
-  if ( this->GetGeometry2D() != NULL )
+  if ( this->GetPlaneGeometry() != NULL )
   {
     for ( i = 0; i < this->GetNumberOfControlPoints(); ++i )
     {
       Point2D p0 = this->GetControlPoint( i );
       Point2D p1 = this->GetControlPoint( (i + 1) % this->GetNumberOfControlPoints() );
 
       area += p0[0] * p1[1] - p1[0] * p0[1];
     }
     area /= 2.0;
   }
 
   this->SetQuantity( FEATURE_ID_AREA, fabs(area) );
 
 }
 
 
 void mitk::PlanarRectangle::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 
   os << indent << "Number of control points: " << this->GetNumberOfControlPoints() << std::endl;
 
   os << indent << "Control points:" << std::endl;
 
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     os << indent << indent << i << ": " <<GetControlPoint( i ) << std::endl;
   }
 }
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
index 564e4908ad..c6e75220ae 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
@@ -1,444 +1,444 @@
 /*===================================================================
 
 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 "mitkPlanarFigureReader.h"
 
 #include "mitkPlanarAngle.h"
 #include "mitkPlanarCircle.h"
 #include "mitkPlanarLine.h"
 #include "mitkPlanarArrow.h"
 #include "mitkPlanarCross.h"
 #include "mitkPlanarFourPointAngle.h"
 #include "mitkPlanarPolygon.h"
 #include "mitkPlanarSubdivisionPolygon.h"
 #include "mitkPlanarRectangle.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlanarEllipse.h"
 #include "mitkPlanarDoubleEllipse.h"
 #include "mitkPlanarBezierCurve.h"
 
 #include "mitkBasePropertySerializer.h"
 
 #include <tinyxml.h>
 #include <itksys/SystemTools.hxx>
 
 
 mitk::PlanarFigureReader::PlanarFigureReader() : PlanarFigureSource(), FileReader(),
 m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
   this->SetNumberOfRequiredOutputs(1);
   this->SetNumberOfIndexedOutputs(1);
   this->SetNthOutput(0, this->MakeOutput(0));
 
   m_CanReadFromMemory = true;
 
 
   //this->Modified();
   //this->GetOutput()->Modified();
   //this->GetOutput()->ReleaseData();
 }
 
 
 mitk::PlanarFigureReader::~PlanarFigureReader()
 {}
 
 
 void mitk::PlanarFigureReader::GenerateData()
 {
   m_Success = false;
   this->SetNumberOfIndexedOutputs(0); // reset all outputs, we add new ones depending on the file content
 
   TiXmlDocument document;
 
   if(m_ReadFromMemory)
   {
     if(m_MemoryBuffer == NULL || m_MemorySize == 0)
     {
       //check
       itkWarningMacro( << "Sorry, memory buffer has not been set!" );
       return;
     }
     if(m_MemoryBuffer[ m_MemorySize - 1 ]  == '\0')
     {
       document.Parse(m_MemoryBuffer);
     }
     else
     {
       char * tmpArray = new char[(int)m_MemorySize+1];
       tmpArray[m_MemorySize] = '\0';
       memcpy(tmpArray,m_MemoryBuffer,m_MemorySize);
 
       document.Parse(m_MemoryBuffer);
 
       delete [] tmpArray;
     }
   }
   else
   {
     if (m_FileName.empty())
     {
       itkWarningMacro( << "Sorry, filename has not been set!" );
       return;
     }
     if (this->CanReadFile( m_FileName.c_str()) == false)
     {
       itkWarningMacro( << "Sorry, can't read file " << m_FileName << "!" );
       return;
     }
     if (!document.LoadFile(m_FileName))
     {
       MITK_ERROR << "Could not open/read/parse " << m_FileName << ". TinyXML reports: '" << document.ErrorDesc() << "'. "
               << "The error occurred in row " << document.ErrorRow() << ", column " << document.ErrorCol() << ".";
       return;
     }
   }
 
   int fileVersion = 1;
   TiXmlElement* versionObject = document.FirstChildElement("Version");
   if (versionObject != NULL)
   {
     if ( versionObject->QueryIntAttribute( "FileVersion", &fileVersion ) != TIXML_SUCCESS )
     {
       MITK_WARN << m_FileName << " does not contain version information! Trying version 1 format." << std::endl;
     }
   }
   else
   {
     MITK_WARN << m_FileName << " does not contain version information! Trying version 1 format." << std::endl;
   }
   if (fileVersion != 1)  // add file version selection and version specific file parsing here, if newer file versions are created
   {
     MITK_WARN << "File version > 1 is not supported by this reader.";
       return;
   }
 
   /* file version 1 reader code */
   for( TiXmlElement* pfElement = document.FirstChildElement("PlanarFigure");
        pfElement != NULL;
        pfElement = pfElement->NextSiblingElement("PlanarFigure") )
   {
     if (pfElement == NULL)
       continue;
 
     std::string type = pfElement->Attribute("type");
 
     mitk::PlanarFigure::Pointer planarFigure = NULL;
     if (type == "PlanarAngle")
     {
       planarFigure = mitk::PlanarAngle::New();
     }
     else if (type == "PlanarCircle")
     {
       planarFigure = mitk::PlanarCircle::New();
     }
     else if (type == "PlanarEllipse")
     {
       planarFigure = mitk::PlanarEllipse::New();
     }
     else if (type == "PlanarCross")
     {
       planarFigure = mitk::PlanarCross::New();
     }
     else if (type == "PlanarFourPointAngle")
     {
       planarFigure = mitk::PlanarFourPointAngle::New();
     }
     else if (type == "PlanarLine")
     {
       planarFigure = mitk::PlanarLine::New();
     }
     else if (type == "PlanarPolygon")
     {
       planarFigure = mitk::PlanarPolygon::New();
     }
     else if (type == "PlanarSubdivisionPolygon")
     {
       planarFigure = mitk::PlanarSubdivisionPolygon::New();
     }
     else if (type == "PlanarRectangle")
     {
       planarFigure = mitk::PlanarRectangle::New();
     }
     else if (type == "PlanarArrow")
     {
       planarFigure = mitk::PlanarArrow::New();
     }
     else if (type == "PlanarDoubleEllipse")
     {
       planarFigure = mitk::PlanarDoubleEllipse::New();
     }
     else if (type == "PlanarBezierCurve")
     {
       planarFigure = mitk::PlanarBezierCurve::New();
     }
     else
     {
       // unknown type
       MITK_WARN << "encountered unknown planar figure type '" << type << "'. Skipping this element.";
       continue;
     }
 
 
     // Read properties of the planar figure
     for( TiXmlElement* propertyElement = pfElement->FirstChildElement("property");
          propertyElement != NULL;
          propertyElement = propertyElement->NextSiblingElement("property") )
     {
       const char* keya = propertyElement->Attribute("key");
       std::string key( keya ? keya : "");
 
       const char* typea = propertyElement->Attribute("type");
       std::string type( typea ? typea : "");
 
       // hand propertyElement to specific reader
       std::stringstream propertyDeserializerClassName;
       propertyDeserializerClassName << type << "Serializer";
 
       std::list<itk::LightObject::Pointer> readers =
         itk::ObjectFactoryBase::CreateAllInstance(propertyDeserializerClassName.str().c_str());
       if (readers.size() < 1)
       {
         MITK_ERROR << "No property reader found for " << type;
       }
       if (readers.size() > 1)
       {
         MITK_WARN << "Multiple property readers found for " << type << ". Using arbitrary first one.";
       }
 
       for ( std::list<itk::LightObject::Pointer>::iterator iter = readers.begin();
         iter != readers.end();
         ++iter )
       {
         if (BasePropertySerializer* reader = dynamic_cast<BasePropertySerializer*>( iter->GetPointer() ) )
         {
           BaseProperty::Pointer property = reader->Deserialize( propertyElement->FirstChildElement() );
           if (property.IsNotNull())
           {
             planarFigure->GetPropertyList()->ReplaceProperty(key, property);
           }
           else
           {
             MITK_ERROR << "There were errors while loading property '" << key << "' of type " << type << ". Your data may be corrupted";
           }
           break;
         }
       }
     }
 
     // If we load a planarFigure, it has definitely been placed correctly.
     // If we do not set this property here, we cannot load old planarFigures
     // without messing up the interaction (PF-Interactor needs this property.
     planarFigure->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
 
 
     // Read geometry of containing plane
     TiXmlElement* geoElement = pfElement->FirstChildElement("Geometry");
     if (geoElement != NULL)
     {
       try
       {
         // Create plane geometry
         mitk::PlaneGeometry::Pointer planeGeo = mitk::PlaneGeometry::New();
 
         // Extract and set plane transform parameters
         DoubleList transformList = this->GetDoubleAttributeListFromXMLNode( geoElement->FirstChildElement( "transformParam" ), "param", 12 );
 
         typedef mitk::BaseGeometry::TransformType TransformType;
         TransformType::ParametersType parameters;
         parameters.SetSize( 12 );
 
         unsigned int i;
         DoubleList::iterator it;
         for ( it = transformList.begin(), i = 0;
               it != transformList.end();
               ++it, ++i )
         {
           parameters.SetElement( i, *it );
         }
 
         typedef mitk::BaseGeometry::TransformType TransformType;
         TransformType::Pointer affineGeometry = TransformType::New();
         affineGeometry->SetParameters( parameters );
         planeGeo->SetIndexToWorldTransform( affineGeometry );
 
 
         // Extract and set plane bounds
         DoubleList boundsList = this->GetDoubleAttributeListFromXMLNode( geoElement->FirstChildElement( "boundsParam" ), "bound", 6 );
 
         typedef mitk::BaseGeometry::BoundsArrayType BoundsArrayType;
 
         BoundsArrayType bounds;
         for ( it = boundsList.begin(), i = 0;
               it != boundsList.end();
               ++it, ++i )
         {
           bounds[i] = *it;
         }
 
         planeGeo->SetBounds( bounds );
 
 
         // Extract and set spacing and origin
         Vector3D spacing = this->GetVectorFromXMLNode(geoElement->FirstChildElement("Spacing"));
         planeGeo->SetSpacing( spacing );
 
         Point3D origin = this->GetPointFromXMLNode(geoElement->FirstChildElement("Origin"));
         planeGeo->SetOrigin( origin );
-        planarFigure->SetGeometry2D(planeGeo);
+        planarFigure->SetPlaneGeometry(planeGeo);
       }
       catch (...)
       {
       }
     }
     TiXmlElement* cpElement = pfElement->FirstChildElement("ControlPoints");
     bool first = true;
     if (cpElement != NULL)
       for( TiXmlElement* vertElement = cpElement->FirstChildElement("Vertex"); vertElement != NULL; vertElement = vertElement->NextSiblingElement("Vertex"))
       {
         if (vertElement == NULL)
           continue;
         int id = 0;
         mitk::Point2D::ValueType x = 0.0;
         mitk::Point2D::ValueType y = 0.0;
         if (vertElement->QueryIntAttribute("id", &id) == TIXML_WRONG_TYPE)
           return; // TODO: can we do a better error handling?
         if (vertElement->QueryDoubleAttribute("x", &x) == TIXML_WRONG_TYPE)
           return; // TODO: can we do a better error handling?
         if (vertElement->QueryDoubleAttribute("y", &y) == TIXML_WRONG_TYPE)
           return; // TODO: can we do a better error handling?
         Point2D p;
         p.SetElement(0, x);
         p.SetElement(1, y);
         if (first == true)  // needed to set m_FigurePlaced to true
         {
           planarFigure->PlaceFigure(p);
           first = false;
         }
         planarFigure->SetControlPoint(id, p, true);
       }
 
     // Calculate feature quantities of this PlanarFigure
     planarFigure->EvaluateFeatures();
 
     // Make sure that no control point is currently selected
     planarFigure->DeselectControlPoint();
 
     // \TODO: what about m_FigurePlaced and m_SelectedControlPoint ??
     this->SetNthOutput( this->GetNumberOfOutputs(), planarFigure );  // add planarFigure as new output of this filter
   }
   m_Success = true;
 }
 
 mitk::Point3D mitk::PlanarFigureReader::GetPointFromXMLNode(TiXmlElement* e)
 {
   if (e == NULL)
     throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
   mitk::Point3D point;
   mitk::ScalarType p(-1.0);
   if (e->QueryDoubleAttribute("x", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   point.SetElement(0, p);
   if (e->QueryDoubleAttribute("y", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   point.SetElement(1, p);
   if (e->QueryDoubleAttribute("z", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   point.SetElement(2, p);
   return point;
 }
 
 
 mitk::Vector3D mitk::PlanarFigureReader::GetVectorFromXMLNode(TiXmlElement* e)
 {
   if (e == NULL)
     throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
   mitk::Vector3D vector;
   mitk::ScalarType p(-1.0);
   if (e->QueryDoubleAttribute("x", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   vector.SetElement(0, p);
   if (e->QueryDoubleAttribute("y", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   vector.SetElement(1, p);
   if (e->QueryDoubleAttribute("z", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   vector.SetElement(2, p);
   return vector;
 }
 
 mitk::PlanarFigureReader::DoubleList
 mitk::PlanarFigureReader::GetDoubleAttributeListFromXMLNode(TiXmlElement* e, const char *attributeNameBase, unsigned int count)
 {
   DoubleList list;
 
   if (e == NULL)
     throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
 
   for ( unsigned int i = 0; i < count; ++i )
   {
     mitk::ScalarType p(-1.0);
     std::stringstream attributeName;
     attributeName << attributeNameBase << i;
 
     if (e->QueryDoubleAttribute( attributeName.str().c_str(), &p ) == TIXML_WRONG_TYPE)
       throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
     list.push_back( p );
   }
 
 
   return list;
 }
 
 void mitk::PlanarFigureReader::GenerateOutputInformation()
 {
 }
 
 int mitk::PlanarFigureReader::CanReadFile ( const char *name )
 {
   if (std::string(name).empty())
     return false;
 
   return (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(name)) == ".pf");  //assume, we can read all .pf files
 
   //TiXmlDocument document(name);
   //if (document.LoadFile() == false)
   //  return false;
   //return (document.FirstChildElement("PlanarFigure") != NULL);
 }
 
 bool mitk::PlanarFigureReader::CanReadFile(const std::string filename, const std::string, const std::string)
 {
   if (filename.empty())
     return false;
 
   return (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(filename)) == ".pf");  //assume, we can read all .pf files
 
   //TiXmlDocument document(filename);
   //if (document.LoadFile() == false)
   //  return false;
   //return (document.FirstChildElement("PlanarFigure") != NULL);
 }
 
 void mitk::PlanarFigureReader::ResizeOutputs( const unsigned int& num )
 {
   unsigned int prevNum = this->GetNumberOfOutputs();
   this->SetNumberOfIndexedOutputs( num );
   for ( unsigned int i = prevNum; i < num; ++i )
   {
     this->SetNthOutput( i, this->MakeOutput( i ).GetPointer() );
   }
 }
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp b/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp
index f2b1cbc8d4..ae5098dfab 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp
@@ -1,303 +1,303 @@
 /*===================================================================
 
 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 "mitkPlanarFigureWriter.h"
 #include "mitkBasePropertySerializer.h"
 
 #include <tinyxml.h>
 
 
 mitk::PlanarFigureWriter::PlanarFigureWriter()
 : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Extension(".pf"),
   m_MimeType("application/MITK.PlanarFigure"), m_Success(false)
 {
   this->SetNumberOfRequiredInputs( 1 );
   this->SetNumberOfIndexedOutputs( 0 );
   //this->SetNthOutput( 0, mitk::PlanarFigure::New().GetPointer() );
 
   m_CanWriteToMemory = true;
 }
 
 
 mitk::PlanarFigureWriter::~PlanarFigureWriter()
 {}
 
 
 void mitk::PlanarFigureWriter::GenerateData()
 {
   m_Success = false;
 
   if (!m_WriteToMemory && m_FileName.empty())
   {
     MITK_ERROR << "Could not write planar figures. File name is invalid";
     throw std::invalid_argument("file name is empty");
   }
 
   TiXmlDocument document;
   TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "", "" ); // TODO what to write here? encoding? etc....
   document.LinkEndChild( decl );
 
   TiXmlElement* version = new TiXmlElement("Version");
   version->SetAttribute("Writer",  __FILE__ );
   version->SetAttribute("CVSRevision",  "$Revision: 17055 $" );
   version->SetAttribute("FileVersion",  1 );
   document.LinkEndChild(version);
 
 
   /* create xml element for each input */
   for ( unsigned int i = 0 ; i < this->GetNumberOfInputs(); ++i )
   {
     // Create root element for this PlanarFigure
     InputType::Pointer pf = this->GetInput( i );
     if (pf.IsNull())
       continue;
     TiXmlElement* pfElement = new TiXmlElement("PlanarFigure");
     pfElement->SetAttribute("type", pf->GetNameOfClass());
     document.LinkEndChild(pfElement);
 
     if ( pf->GetNumberOfControlPoints() == 0 )
       continue;
 
     //PlanarFigure::VertexContainerType* vertices = pf->GetControlPoints();
     //if (vertices == NULL)
     //  continue;
 
     // Serialize property list of PlanarFigure
     mitk::PropertyList::Pointer propertyList = pf->GetPropertyList();
     mitk::PropertyList::PropertyMap::const_iterator it;
     for ( it = propertyList->GetMap()->begin(); it != propertyList->GetMap()->end(); ++it )
     {
       // Create seralizer for this property
       const mitk::BaseProperty* prop = it->second;
       std::string serializerName = std::string( prop->GetNameOfClass() ) + "Serializer";
       std::list< itk::LightObject::Pointer > allSerializers = itk::ObjectFactoryBase::CreateAllInstance(
         serializerName.c_str() );
 
       if ( allSerializers.size() != 1 )
       {
         // No or too many serializer(s) found, skip this property
         continue;
       }
 
       mitk::BasePropertySerializer* serializer = dynamic_cast< mitk::BasePropertySerializer* >(
         allSerializers.begin()->GetPointer() );
       if ( serializer == NULL )
       {
         // Serializer not valid; skip this property
       }
 
       TiXmlElement* keyElement = new TiXmlElement( "property" );
       keyElement->SetAttribute( "key", it->first );
       keyElement->SetAttribute( "type", prop->GetNameOfClass() );
 
         serializer->SetProperty( prop );
       TiXmlElement* valueElement = NULL;
       try
       {
         valueElement = serializer->Serialize();
       }
       catch (...)
       {
       }
 
       if ( valueElement == NULL )
       {
         // Serialization failed; skip this property
         continue;
       }
 
       // Add value to property element
       keyElement->LinkEndChild( valueElement );
 
       // Append serialized property to property list
       pfElement->LinkEndChild( keyElement );
     }
 
     // Serialize control points of PlanarFigure
     TiXmlElement* controlPointsElement = new TiXmlElement("ControlPoints");
     pfElement->LinkEndChild(controlPointsElement);
     for (unsigned int i = 0; i < pf->GetNumberOfControlPoints(); i++)
     {
       TiXmlElement* vElement = new TiXmlElement("Vertex");
       vElement->SetAttribute("id", i);
       vElement->SetDoubleAttribute("x", pf->GetControlPoint(i)[0]);
       vElement->SetDoubleAttribute("y", pf->GetControlPoint(i)[1]);
       controlPointsElement->LinkEndChild(vElement);
     }
     TiXmlElement* geoElement = new TiXmlElement("Geometry");
-    const PlaneGeometry* planeGeo = dynamic_cast<const PlaneGeometry*>(pf->GetGeometry2D());
+    const PlaneGeometry* planeGeo = dynamic_cast<const PlaneGeometry*>(pf->GetPlaneGeometry());
     if (planeGeo != NULL)
     {
       // Write parameters of IndexToWorldTransform of the PlaneGeometry
       typedef mitk::Geometry3D::TransformType TransformType;
       const TransformType* affineGeometry = planeGeo->GetIndexToWorldTransform();
       const TransformType::ParametersType& parameters = affineGeometry->GetParameters();
       TiXmlElement* vElement = new TiXmlElement( "transformParam" );
       for ( unsigned int i = 0; i < affineGeometry->GetNumberOfParameters(); ++i )
       {
         std::stringstream paramName;
         paramName << "param" << i;
         vElement->SetDoubleAttribute( paramName.str().c_str(), parameters.GetElement( i ) );
       }
       geoElement->LinkEndChild( vElement );
 
       // Write bounds of the PlaneGeometry
       typedef mitk::Geometry3D::BoundsArrayType BoundsArrayType;
       const BoundsArrayType& bounds = planeGeo->GetBounds();
       vElement = new TiXmlElement( "boundsParam" );
       for ( unsigned int i = 0; i < 6; ++i )
       {
         std::stringstream boundName;
         boundName << "bound" << i;
         vElement->SetDoubleAttribute( boundName.str().c_str(), bounds.GetElement( i ) );
       }
       geoElement->LinkEndChild( vElement );
 
       // Write spacing and origin of the PlaneGeometry
       Vector3D spacing = planeGeo->GetSpacing();
       Point3D origin = planeGeo->GetOrigin();
       geoElement->LinkEndChild(this->CreateXMLVectorElement("Spacing", spacing));
       geoElement->LinkEndChild(this->CreateXMLVectorElement("Origin", origin));
 
       pfElement->LinkEndChild(geoElement);
     }
   }
 
 
   if(m_WriteToMemory)
   {
     // Declare a printer
     TiXmlPrinter printer;
     // attach it to the document you want to convert in to a std::string
     document.Accept(&printer);
 
     // Create memory buffer and print tinyxmldocument there...
     m_MemoryBufferSize  = printer.Size() + 1;
     m_MemoryBuffer      = new char[m_MemoryBufferSize];
     strcpy(m_MemoryBuffer,printer.CStr());
   }
   else
   {
     if (document.SaveFile( m_FileName) == false)
     {
       MITK_ERROR << "Could not write planar figures to " << m_FileName << "\nTinyXML reports '" << document.ErrorDesc() << "'";
       throw std::ios_base::failure("Error during writing of planar figure xml file.");
     }
   }
   m_Success = true;
 }
 
 void mitk::PlanarFigureWriter::ReleaseMemory()
 {
   if(m_MemoryBuffer != NULL)
   {
     delete [] m_MemoryBuffer;
   }
 }
 
 
 TiXmlElement* mitk::PlanarFigureWriter::CreateXMLVectorElement(const char* name, itk::FixedArray<mitk::ScalarType, 3> v)
 {
   TiXmlElement* vElement = new TiXmlElement(name);
   vElement->SetDoubleAttribute("x", v.GetElement(0));
   vElement->SetDoubleAttribute("y", v.GetElement(1));
   vElement->SetDoubleAttribute("z", v.GetElement(2));
   return vElement;
 }
 
 
 void mitk::PlanarFigureWriter::ResizeInputs( const unsigned int& num )
 {
   //unsigned int prevNum = this->GetNumberOfInputs();
   this->SetNumberOfIndexedInputs( num );
   //for ( unsigned int i = prevNum; i < num; ++i )
   //{
   //  this->SetNthInput( i, mitk::PlanarFigure::New().GetPointer() );
   //}
 }
 
 
 void mitk::PlanarFigureWriter::SetInput( InputType* PlanarFigure )
 {
   this->ProcessObject::SetNthInput( 0, PlanarFigure );
 }
 
 
 void mitk::PlanarFigureWriter::SetInput( const unsigned int& id, InputType* PlanarFigure )
 {
   if ( id >= this->GetNumberOfInputs() )
     this->ResizeInputs( id + 1 );
   this->ProcessObject::SetNthInput( id, PlanarFigure );
 }
 
 
 mitk::PlanarFigure* mitk::PlanarFigureWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
     return NULL;
   else
     return dynamic_cast<InputType*> ( this->GetInput( 0 ) );
 }
 
 
 mitk::PlanarFigure* mitk::PlanarFigureWriter::GetInput( const unsigned int& num )
 {
   return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( num ) );
 }
 
 
 bool mitk::PlanarFigureWriter::CanWriteDataType( DataNode* input )
 {
   if ( input == NULL )
     return false;
 
   mitk::BaseData* data = input->GetData();
   if ( data  == NULL)
     return false;
 
   mitk::PlanarFigure::Pointer PlanarFigure = dynamic_cast<mitk::PlanarFigure*>( data );
   if( PlanarFigure.IsNull() )
     return false;
   // add code for special subclasses here
   return true;
 }
 
 
 void mitk::PlanarFigureWriter::SetInput( DataNode* input )
 {
   if (this->CanWriteDataType(input))
     this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::PlanarFigure*>( input->GetData() ) );
 }
 
 
 std::string mitk::PlanarFigureWriter::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 
 std::vector<std::string> mitk::PlanarFigureWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(m_Extension);
   return possibleFileExtensions;
 }
 
 
 std::string mitk::PlanarFigureWriter::GetFileExtension()
 {
   return m_Extension;
 }
diff --git a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
index 3560052733..347e32b219 100644
--- a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
+++ b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
@@ -1,947 +1,947 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #define PLANARFIGUREINTERACTOR_DBG MITK_DEBUG("PlanarFigureInteractor") << __LINE__ << ": "
 
 #include "mitkPlanarFigureInteractor.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarPolygon.h"
 
 #include "mitkInteractionPositionEvent.h"
 #include "mitkInternalEvent.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 
 
 //how precise must the user pick the point
 //default value
 mitk::PlanarFigureInteractor::PlanarFigureInteractor()
 : DataInteractor()
 , m_Precision( 6.5 )
 , m_MinimumPointDistance( 25.0 )
 , m_IsHovering( false )
 , m_LastPointWasValid( false )
 {
 }
 
 mitk::PlanarFigureInteractor::~PlanarFigureInteractor()
 {
 }
 
 void mitk::PlanarFigureInteractor::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("figure_is_on_current_slice", CheckFigureOnRenderingGeometry);
   CONNECT_CONDITION("figure_is_placed", CheckFigurePlaced);
   CONNECT_CONDITION("minimal_figure_is_finished", CheckMinimalFigureFinished);
   CONNECT_CONDITION("hovering_above_figure", CheckFigureHovering);
   CONNECT_CONDITION("hovering_above_point", CheckControlPointHovering);
   CONNECT_CONDITION("figure_is_selected", CheckSelection);
   CONNECT_CONDITION("point_is_valid", CheckPointValidity);
   CONNECT_CONDITION("figure_is_finished", CheckFigureFinished);
   CONNECT_CONDITION("reset_on_point_select_needed", CheckResetOnPointSelect);
   CONNECT_CONDITION("points_can_be_added_or_removed", CheckFigureIsExtendable);
 
 
   CONNECT_FUNCTION( "finalize_figure", FinalizeFigure);
   CONNECT_FUNCTION( "hide_preview_point", HidePreviewPoint )
   CONNECT_FUNCTION( "hide_control_points", HideControlPoints )
   CONNECT_FUNCTION( "set_preview_point_position", SetPreviewPointPosition )
   CONNECT_FUNCTION( "move_current_point", MoveCurrentPoint);
   CONNECT_FUNCTION( "deselect_point", DeselectPoint);
   CONNECT_FUNCTION( "add_new_point", AddPoint);
   CONNECT_FUNCTION( "add_initial_point", AddInitialPoint);
   CONNECT_FUNCTION( "remove_selected_point", RemoveSelectedPoint);
   CONNECT_FUNCTION( "request_context_menu", RequestContextMenu);
   CONNECT_FUNCTION( "select_figure", SelectFigure );
   CONNECT_FUNCTION( "select_point", SelectPoint );
   CONNECT_FUNCTION( "end_interaction", EndInteraction );
   CONNECT_FUNCTION( "start_hovering", StartHovering )
   CONNECT_FUNCTION( "end_hovering", EndHovering );
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigurePlaced( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   bool isFigureFinished = false;
   planarFigure->GetPropertyList()->GetBoolProperty( "initiallyplaced", isFigureFinished );
 
   return planarFigure->IsPlaced() && isFigureFinished;
 }
 
 bool mitk::PlanarFigureInteractor::MoveCurrentPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   bool isEditable = true;
   GetDataNode()->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
   mitk::PlaneGeometry *planarFigureGeometry =
     dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
 
   // Extract point in 2D world coordinates (relative to PlaneGeometry of
   // PlanarFigure)
   Point2D point2D;
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) || !isEditable )
   {
     return false;
   }
 
   // check if the control points shall be hidden during interaction
   bool hidecontrolpointsduringinteraction = false;
   GetDataNode()->GetBoolProperty( "planarfigure.hidecontrolpointsduringinteraction", hidecontrolpointsduringinteraction );
 
   // hide the control points if necessary
   //interactionEvent->GetSender()->GetDataStorage()->BlockNodeModifiedEvents( true );
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", !hidecontrolpointsduringinteraction );
   //interactionEvent->GetSender()->GetDataStorage()->BlockNodeModifiedEvents( false );
 
   // Move current control point to this point
   planarFigure->SetCurrentControlPoint( point2D );
 
   // Re-evaluate features
   planarFigure->EvaluateFeatures();
 
   // Update rendered scene
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::FinalizeFigure( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   planarFigure->Modified();
   planarFigure->DeselectControlPoint();
   planarFigure->RemoveLastControlPoint();
   planarFigure->SetProperty( "initiallyplaced", mitk::BoolProperty::New( true ) );
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
   GetDataNode()->Modified();
   planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() );
   planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
 
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::EndInteraction( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
   planarFigure->Modified();
   planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::EndHovering( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   planarFigure->ResetPreviewContolPoint();
 
   // Invoke end-hover event once the mouse is exiting the figure area
   m_IsHovering = false;
   planarFigure->InvokeEvent( EndHoverPlanarFigureEvent() );
 
   // Set bool property to indicate that planar figure is no longer in "hovering" mode
   GetDataNode()->SetBoolProperty( "planarfigure.ishovering", false );
 
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::CheckMinimalFigureFinished( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   return ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMinimumNumberOfControlPoints()  );
 }
 
 bool mitk::PlanarFigureInteractor::CheckFigureFinished( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   return ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints() );
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigureIsExtendable( const InteractionEvent* /*interactionEvent*/ )
 {
   bool isExtendable = false;
   GetDataNode()->GetBoolProperty("planarfigure.isextendable", isExtendable);
 
   return isExtendable;
 }
 
 bool mitk::PlanarFigureInteractor::DeselectPoint(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
   bool wasSelected = planarFigure->DeselectControlPoint();
   if ( wasSelected )
   {
     // Issue event so that listeners may update themselves
     planarFigure->Modified();
     planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
 
     GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
 //    GetDataNode()->SetBoolProperty( "planarfigure.ishovering", false );
     GetDataNode()->Modified();
   }
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::AddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   bool selected = false;
   bool isEditable = true;
   GetDataNode()->GetBoolProperty("selected", selected);
   GetDataNode()->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
   if ( !selected || !isEditable )
   {
     return false;
   }
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
   mitk::PlaneGeometry *planarFigureGeometry =
     dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
 
   // If the planarFigure already has reached the maximum number
   if ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints() )
   {
     return false;
   }
 
   // Extract point in 2D world coordinates (relative to PlaneGeometry of
   // PlanarFigure)
   Point2D point2D, projectedPoint;
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) )
   {
     return false;
   }
 
   // TODO: check segment of polyline we clicked in
   int nextIndex = -1;
 
   // We only need to check which position to insert the control point
   // when interacting with a PlanarPolygon. For all other types
   // new control points will always be appended
 
   /*
   * Added check for "initiallyplaced" due to bug 13097:
   *
   * There are two possible cases in which a point can be inserted into a PlanarPolygon:
   *
   * 1. The figure is currently drawn -> the point will be appended at the end of the figure
   * 2. A point is inserted at a userdefined position after the initial placement of the figure is finished
   *
   * In the second case we need to determine the proper insertion index. In the first case the index always has
   * to be -1 so that the point is appended to the end.
   *
   * These changes are necessary because of a mac os x specific issue: If a users draws a PlanarPolygon then the
   * next point to be added moves according to the mouse position. If then the user left clicks in order to add
   * a point one would assume the last move position is identical to the left click position. This is actually the
   * case for windows and linux but somehow NOT for mac. Because of the insertion logic of a new point in the
   * PlanarFigure then for mac the wrong current selected point is determined.
   *
   * With this check here this problem can be avoided. However a redesign of the insertion logic should be considered
   */
   bool isFigureFinished = false;
   planarFigure->GetPropertyList()->GetBoolProperty( "initiallyplaced", isFigureFinished );
 
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
-  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldGeometry2D();
+  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
 
   if ( dynamic_cast<mitk::PlanarPolygon*>( planarFigure ) && isFigureFinished)
   {
     nextIndex = this->IsPositionOverFigure(
       positionEvent,
       planarFigure,
       planarFigureGeometry,
       projectionPlane,
       renderer->GetDisplayGeometry(),
       projectedPoint
       );
   }
 
 
   // Add point as new control point
   renderer->GetDisplayGeometry()->DisplayToWorld( projectedPoint, projectedPoint );
 
   if ( planarFigure->IsPreviewControlPointVisible() )
   {
     point2D = planarFigure->GetPreviewControlPoint();
   }
 
   planarFigure->AddControlPoint( point2D, nextIndex );
 
   if ( planarFigure->IsPreviewControlPointVisible() )
   {
     planarFigure->SelectControlPoint( nextIndex );
     planarFigure->ResetPreviewContolPoint();
   }
 
   // Re-evaluate features
   planarFigure->EvaluateFeatures();
   //this->LogPrintPlanarFigureQuantities( planarFigure );
 
   // Update rendered scene
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::AddInitialPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::PlaneGeometry *planarFigureGeometry = dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
 
   // Invoke event to notify listeners that placement of this PF starts now
   planarFigure->InvokeEvent( StartPlacementPlanarFigureEvent() );
 
   // Use PlaneGeometry of the renderer clicked on for this PlanarFigure
   mitk::PlaneGeometry *planeGeometry = const_cast< mitk::PlaneGeometry * >(
     dynamic_cast< const mitk::PlaneGeometry * >(
     renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry() ) );
   if ( planeGeometry != NULL )
   {
     planarFigureGeometry = planeGeometry;
-    planarFigure->SetGeometry2D( planeGeometry );
+    planarFigure->SetPlaneGeometry( planeGeometry );
   }
   else
   {
     return false;
   }
 
   // Extract point in 2D world coordinates (relative to PlaneGeometry of
   // PlanarFigure)
   Point2D point2D;
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) )
   {
     return false;
   }
 
   // Place PlanarFigure at this point
   planarFigure->PlaceFigure( point2D );
 
   // Re-evaluate features
   planarFigure->EvaluateFeatures();
   //this->LogPrintPlanarFigureQuantities( planarFigure );
 
   // Set a bool property indicating that the figure has been placed in
   // the current RenderWindow. This is required so that the same render
   // window can be re-aligned to the PlaneGeometry of the PlanarFigure later
   // on in an application.
   GetDataNode()->SetBoolProperty( "PlanarFigureInitializedWindow", true, renderer );
 
   // Update rendered scene
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::StartHovering( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
 
   if ( !m_IsHovering )
   {
     // Invoke hover event once when the mouse is entering the figure area
     m_IsHovering = true;
     planarFigure->InvokeEvent( StartHoverPlanarFigureEvent() );
 
     // Set bool property to indicate that planar figure is currently in "hovering" mode
     GetDataNode()->SetBoolProperty( "planarfigure.ishovering", true );
 
     renderer->GetRenderingManager()->RequestUpdateAll();
   }
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::SetPreviewPointPosition( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
 
   planarFigure->DeselectControlPoint();
 
   mitk::Point2D pointProjectedOntoLine = positionEvent->GetPointerPositionOnScreen();
 
   bool selected(false);
   bool isExtendable(false);
   bool isEditable(true);
   GetDataNode()->GetBoolProperty("selected", selected);
   GetDataNode()->GetBoolProperty("planarfigure.isextendable", isExtendable);
   GetDataNode()->GetBoolProperty("planarfigure.iseditable", isEditable );
 
   if ( selected &&  isExtendable && isEditable )
   {
     renderer->GetDisplayGeometry()->DisplayToWorld( pointProjectedOntoLine, pointProjectedOntoLine );
     planarFigure->SetPreviewControlPoint( pointProjectedOntoLine );
   }
 
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::HideControlPoints( StateMachineAction*, InteractionEvent* /*interactionEvent*/ )
 {
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", false );
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::HidePreviewPoint( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   planarFigure->ResetPreviewContolPoint();
 
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigureHovering( const InteractionEvent* interactionEvent )
 {
   const mitk::InteractionPositionEvent* positionEvent = dynamic_cast<const mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::PlaneGeometry *planarFigureGeometry = dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
-  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldGeometry2D();
+  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
 
   mitk::Point2D pointProjectedOntoLine;
   int previousControlPoint = this->IsPositionOverFigure( positionEvent,
                                                          planarFigure,
                                                          planarFigureGeometry,
                                                          projectionPlane,
                                                          renderer->GetDisplayGeometry(),
                                                          pointProjectedOntoLine
                                                         );
 
   bool isHovering = (previousControlPoint != -1);
 
   if ( isHovering )
   {
     return true;
   }
   else
   {
     return false;
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckControlPointHovering( const InteractionEvent* interactionEvent )
 {
   const mitk::InteractionPositionEvent* positionEvent = dynamic_cast<const mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::PlaneGeometry *planarFigureGeometry = dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
-  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldGeometry2D();
+  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
 
 
   int pointIndex = -1;
   pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
     positionEvent,
     planarFigure,
     planarFigureGeometry,
     projectionPlane,
     renderer->GetDisplayGeometry() );
 
   if ( pointIndex >= 0 )
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::PlanarFigureInteractor::CheckSelection( const InteractionEvent* /*interactionEvent*/ )
 {
   bool selected = false;
   GetDataNode()->GetBoolProperty("selected", selected);
 
   return selected;
 }
 
 bool mitk::PlanarFigureInteractor::SelectFigure( StateMachineAction*, InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   planarFigure->InvokeEvent( SelectPlanarFigureEvent() );
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::SelectPoint( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::PlaneGeometry *planarFigureGeometry = dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
-  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldGeometry2D();
+  const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
 
 
   int pointIndex = -1;
   pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
     positionEvent,
     planarFigure,
     planarFigureGeometry,
     projectionPlane,
     renderer->GetDisplayGeometry() );
 
   if ( pointIndex >= 0 )
   {
     // If mouse is above control point, mark it as selected
     planarFigure->SelectControlPoint( pointIndex );
   }
   else
   {
     planarFigure->DeselectControlPoint();
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckPointValidity( const InteractionEvent* interactionEvent )
 {
   // Check if the distance of the current point to the previously set point in display coordinates
   // is sufficient (if a previous point exists)
 
   // Extract display position
   const mitk::InteractionPositionEvent* positionEvent = dynamic_cast<const mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   m_LastPointWasValid = IsMousePositionAcceptableAsNewControlPoint( positionEvent, planarFigure );
   return m_LastPointWasValid;
 }
 
 
 
 bool mitk::PlanarFigureInteractor::RemoveSelectedPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
 
   int selectedControlPoint = planarFigure->GetSelectedControlPoint();
   planarFigure->RemoveControlPoint( selectedControlPoint );
 
   // Re-evaluate features
   planarFigure->EvaluateFeatures();
   planarFigure->Modified();
 
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
   planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   HandleEvent( mitk::InternalEvent::New( renderer, this, "Dummy-Event" ), GetDataNode() );
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::RequestContextMenu(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   bool selected = false;
   GetDataNode()->GetBoolProperty("selected", selected);
 
   // no need to invoke this if the figure is already selected
   if ( !selected )
   {
     planarFigure->InvokeEvent( SelectPlanarFigureEvent() );
   }
 
   planarFigure->InvokeEvent( ContextMenuPlanarFigureEvent() );
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckResetOnPointSelect( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   // Invoke tmpEvent to notify listeners that interaction with this PF starts now
   planarFigure->InvokeEvent( StartInteractionPlanarFigureEvent() );
 
   // Reset the PlanarFigure if required
   return planarFigure->ResetOnPointSelect();
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigureOnRenderingGeometry( const InteractionEvent* interactionEvent )
 {
   const mitk::InteractionPositionEvent* posEvent = dynamic_cast<const mitk::InteractionPositionEvent*>(interactionEvent);
 
   if ( posEvent == NULL )
     return false;
 
   mitk::Point3D worldPoint3D = posEvent->GetPositionInWorld();
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
-  mitk::PlaneGeometry *planarFigureGeometry2D = dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
+  mitk::PlaneGeometry *planarFigurePlaneGeometry = dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
 
-  double planeThickness = planarFigureGeometry2D->GetExtentInMM( 2 );
+  double planeThickness = planarFigurePlaneGeometry->GetExtentInMM( 2 );
 
-  if ( planarFigureGeometry2D->Distance( worldPoint3D ) > planeThickness )
+  if ( planarFigurePlaneGeometry->Distance( worldPoint3D ) > planeThickness )
   {
     // don't react, when interaction is too far away
     return false;
   }
   return true;
 }
 
 void mitk::PlanarFigureInteractor::SetPrecision( mitk::ScalarType precision )
 {
   m_Precision = precision;
 }
 
 
 void mitk::PlanarFigureInteractor::SetMinimumPointDistance( ScalarType minimumDistance )
 {
   m_MinimumPointDistance = minimumDistance;
 }
 
 
 bool mitk::PlanarFigureInteractor::TransformPositionEventToPoint2D( const InteractionPositionEvent *positionEvent,
                                                                     const PlaneGeometry *planarFigureGeometry,
                                                                     Point2D &point2D )
 {
   mitk::Point3D worldPoint3D = positionEvent->GetPositionInWorld();
 
   // TODO: proper handling of distance tolerance
   if ( planarFigureGeometry->Distance( worldPoint3D ) > 0.1 )
   {
     return false;
   }
 
   // Project point onto plane of this PlanarFigure
   planarFigureGeometry->Map( worldPoint3D, point2D );
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::PlaneGeometry *objectGeometry,
   const mitk::PlaneGeometry *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry ) const
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // TODO: proper handling of distance tolerance
   if ( displayGeometry->Distance( point3D ) < 0.1 )
   {
     // Project 3D world point onto display geometry
     rendererGeometry->Map( point3D, displayPoint );
     displayGeometry->WorldToDisplay( displayPoint, displayPoint );
     return true;
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::IsPointNearLine(
   const mitk::Point2D& point,
   const mitk::Point2D& startPoint,
   const mitk::Point2D& endPoint,
   mitk::Point2D& projectedPoint
   ) const
 {
   mitk::Vector2D n1 = endPoint - startPoint;
   n1.Normalize();
 
   // Determine dot products between line vector and startpoint-point / endpoint-point vectors
   double l1 = n1 * (point - startPoint);
   double l2 = -n1 * (point - endPoint);
 
   // Determine projection of specified point onto line defined by start / end point
   mitk::Point2D crossPoint = startPoint + n1 * l1;
   projectedPoint = crossPoint;
 
   // Point is inside encompassing rectangle IF
   // - its distance to its projected point is small enough
   // - it is not further outside of the line than the defined tolerance
   if (((crossPoint.SquaredEuclideanDistanceTo(point) < 20.0) && (l1 > 0.0) && (l2 > 0.0))
       || endPoint.SquaredEuclideanDistanceTo(point) < 20.0
       || startPoint.SquaredEuclideanDistanceTo(point) < 20.0)
   {
     return true;
   }
 
   return false;
 }
 
 
 int mitk::PlanarFigureInteractor::IsPositionOverFigure(
   const InteractionPositionEvent *positionEvent,
   PlanarFigure *planarFigure,
   const PlaneGeometry *planarFigureGeometry,
   const PlaneGeometry *rendererGeometry,
   const DisplayGeometry *displayGeometry,
   Point2D& pointProjectedOntoLine ) const
 {
   mitk::Point2D displayPosition = positionEvent->GetPointerPositionOnScreen();
 
   // Iterate over all polylines of planar figure, and check if
   // any one is close to the current display position
   typedef mitk::PlanarFigure::PolyLineType VertexContainerType;
 
   Point2D polyLinePoint;
   Point2D firstPolyLinePoint;
   Point2D previousPolyLinePoint;
 
   for ( unsigned short loop=0; loop<planarFigure->GetPolyLinesSize(); ++loop )
   {
     const VertexContainerType polyLine = planarFigure->GetPolyLine( loop );
 
     bool firstPoint( true );
     for ( VertexContainerType::const_iterator it = polyLine.begin(); it != polyLine.end(); ++it )
     {
       // Get plane coordinates of this point of polyline (if possible)
       if ( !this->TransformObjectToDisplay( it->Point,
                                             polyLinePoint,
                                             planarFigureGeometry,
                                             rendererGeometry,
                                             displayGeometry )
                                            )
       {
         break; // Poly line invalid (not on current 2D plane) --> skip it
       }
 
       if ( firstPoint )
       {
         firstPolyLinePoint = polyLinePoint;
         firstPoint = false;
       }
       else if ( this->IsPointNearLine( displayPosition, previousPolyLinePoint, polyLinePoint, pointProjectedOntoLine ) )
       {
         // Point is close enough to line segment --> Return index of the segment
         return it->Index;
       }
       previousPolyLinePoint = polyLinePoint;
     }
 
     // For closed figures, also check last line segment
     if ( planarFigure->IsClosed()
       && this->IsPointNearLine( displayPosition, polyLinePoint, firstPolyLinePoint, pointProjectedOntoLine ) )
     {
       return 0; // Return index of first control point
     }
   }
   return -1;
 }
 
 
 int mitk::PlanarFigureInteractor::IsPositionInsideMarker(
   const InteractionPositionEvent* positionEvent,
   const PlanarFigure *planarFigure,
   const PlaneGeometry *planarFigureGeometry,
   const PlaneGeometry *rendererGeometry,
   const DisplayGeometry *displayGeometry ) const
 {
   mitk::Point2D displayPosition = positionEvent->GetPointerPositionOnScreen();
 
   // Iterate over all control points of planar figure, and check if
   // any one is close to the current display position
   mitk::Point2D displayControlPoint;
 
   int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
   for ( int i=0; i<numberOfControlPoints; i++ )
   {
     if ( this->TransformObjectToDisplay( planarFigure->GetControlPoint(i), displayControlPoint,
       planarFigureGeometry, rendererGeometry, displayGeometry ) )
     {
       // TODO: variable size of markers
       if ( displayPosition.SquaredEuclideanDistanceTo( displayControlPoint ) < 20.0 )
       {
         return i;
       }
     }
   }
 
   return -1;
 }
 
 
 void mitk::PlanarFigureInteractor::LogPrintPlanarFigureQuantities(
   const PlanarFigure *planarFigure )
 {
   MITK_INFO << "PlanarFigure: " << planarFigure->GetNameOfClass();
   for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
   {
     MITK_INFO << "* " << planarFigure->GetFeatureName( i ) << ": "
       << planarFigure->GetQuantity( i ) << " " << planarFigure->GetFeatureUnit( i );
   }
 }
 
 bool
 mitk::PlanarFigureInteractor::IsMousePositionAcceptableAsNewControlPoint(
     const mitk::InteractionPositionEvent* positionEvent,
     const PlanarFigure* planarFigure )
 {
   assert(positionEvent && planarFigure);
 
   BaseRenderer* renderer = positionEvent->GetSender();
   assert(renderer);
 
   // Get the timestep to support 3D+t
   int timeStep( renderer->GetTimeStep( planarFigure ) );
 
   bool tooClose(false);
 
-  const PlaneGeometry *renderingPlane = renderer->GetCurrentWorldGeometry2D();
+  const PlaneGeometry *renderingPlane = renderer->GetCurrentWorldPlaneGeometry();
 
   mitk::PlaneGeometry *planarFigureGeometry =
     dynamic_cast< mitk::PlaneGeometry * >( planarFigure->GetGeometry( timeStep ) );
 
   Point2D point2D, correctedPoint;
   // Get the point2D from the positionEvent
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) )
   {
     return false;
   }
 
   // apply the controlPoint constraints of the planarFigure to get the
   // coordinates that would actually be used.
   correctedPoint = const_cast<PlanarFigure*>( planarFigure )->ApplyControlPointConstraints( 0, point2D );
 
   // map the 2D coordinates of the new point to world-coordinates
   // and transform those to display-coordinates
   mitk::Point3D newPoint3D;
   planarFigureGeometry->Map( correctedPoint, newPoint3D );
   mitk::Point2D newDisplayPosition;
   renderingPlane->Map( newPoint3D, newDisplayPosition );
   renderer->GetDisplayGeometry()->WorldToDisplay( newDisplayPosition, newDisplayPosition );
 
   for( int i=0; i < (int)planarFigure->GetNumberOfControlPoints(); i++ )
   {
     if ( i != planarFigure->GetSelectedControlPoint() )
     {
       // Try to convert previous point to current display coordinates
       mitk::Point3D previousPoint3D;
       // map the 2D coordinates of the control-point to world-coordinates
       planarFigureGeometry->Map( planarFigure->GetControlPoint( i ), previousPoint3D );
 
       if ( renderer->GetDisplayGeometry()->Distance( previousPoint3D ) < 0.1 ) // ugly, but assert makes this work
       {
         mitk::Point2D previousDisplayPosition;
         // transform the world-coordinates into display-coordinates
         renderingPlane->Map( previousPoint3D, previousDisplayPosition );
         renderer->GetDisplayGeometry()->WorldToDisplay( previousDisplayPosition, previousDisplayPosition );
 
         //Calculate the distance. We use display-coordinates here to make
         // the check independent of the zoom-level of the rendering scene.
         double a = newDisplayPosition[0] - previousDisplayPosition[0];
         double b = newDisplayPosition[1] - previousDisplayPosition[1];
 
         // If point is to close, do not set a new point
         tooClose = (a * a + b * b < m_MinimumPointDistance );
       }
       if ( tooClose )
         return false; // abort loop early
     }
   }
 
   return !tooClose; // default
 }
 
 void mitk::PlanarFigureInteractor::ConfigurationChanged()
 {
   mitk::PropertyList::Pointer properties = GetAttributes();
 
   std::string precision = "";
   if (properties->GetStringProperty("precision", precision))
   {
     m_Precision = atof(precision.c_str());
   }
   else
   {
     m_Precision = (ScalarType) 6.5;
   }
 
   std::string minPointDistance = "";
   if (properties->GetStringProperty("minPointDistance", minPointDistance))
   {
     m_MinimumPointDistance = atof(minPointDistance.c_str());
   }
   else
   {
     m_MinimumPointDistance = (ScalarType) 25.0;
   }
 }
 
 
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
index caf160030e..8c56f6d131 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,927 +1,923 @@
 /*===================================================================
 
 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 "mitkPlanarFigureMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkGL.h"
 #include "mitkVtkPropRenderer.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // offset which moves the planarfigures on top of the other content
 // the crosshair is rendered into the z = 1 layer.
 static const float PLANAR_OFFSET = 0.5f;
 
 mitk::PlanarFigureMapper2D::PlanarFigureMapper2D()
   : m_NodeModified(true)
   , m_NodeModifiedObserverTag(0)
   , m_NodeModifiedObserverAdded(false)
 {
   this->InitializeDefaultPlanarFigureProperties();
 }
 
 
 mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
 {
   if ( m_NodeModifiedObserverAdded && GetDataNode() != NULL )
   {
     GetDataNode()->RemoveObserver( m_NodeModifiedObserverTag );
   }
 }
 
 
 void mitk::PlanarFigureMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible ) return;
 
 
   // Get PlanarFigure from input
   mitk::PlanarFigure *planarFigure = const_cast< mitk::PlanarFigure * >(
     static_cast< const mitk::PlanarFigure * >( GetDataNode()->GetData() ) );
 
   // Check if PlanarFigure has already been placed; otherwise, do nothing
   if ( !planarFigure->IsPlaced() )
   {
     return;
   }
 
   // Get 2D geometry frame of PlanarFigure
-  mitk::PlaneGeometry *planarFigureGeometry2D =
+  mitk::PlaneGeometry *planarFigurePlaneGeometry =
     dynamic_cast< PlaneGeometry * >( planarFigure->GetGeometry( 0 ) );
-  if ( planarFigureGeometry2D == NULL )
+  if ( planarFigurePlaneGeometry == NULL )
   {
     MITK_ERROR << "PlanarFigure does not have valid PlaneGeometry!";
     return;
   }
 
   // Get current world 2D geometry from renderer
-  const mitk::PlaneGeometry *rendererGeometry2D = renderer->GetCurrentWorldGeometry2D();
+  const mitk::PlaneGeometry *rendererPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry();
 
   // If the PlanarFigure geometry is a plane geometry, check if current
   // world plane is parallel to and within the planar figure geometry bounds
   // (otherwise, display nothing)
-  mitk::PlaneGeometry *planarFigurePlaneGeometry =
-    dynamic_cast< PlaneGeometry * >( planarFigureGeometry2D );
-  const mitk::PlaneGeometry *rendererPlaneGeometry =
-    dynamic_cast< const PlaneGeometry * >( rendererGeometry2D );
 
   if ( (planarFigurePlaneGeometry != NULL) && (rendererPlaneGeometry != NULL) )
   {
     double planeThickness = planarFigurePlaneGeometry->GetExtentInMM( 2 );
     if ( !planarFigurePlaneGeometry->IsParallel( rendererPlaneGeometry )
       || !(planarFigurePlaneGeometry->DistanceFromPlane(
       rendererPlaneGeometry ) < planeThickness / 3.0) )
     {
       // Planes are not parallel or renderer plane is not within PlanarFigure
       // geometry bounds --> exit
       return;
     }
   }
   else
   {
     // Plane is not valid (curved reformations are not possible yet)
     return;
   }
 
 
   // Get display geometry
   mitk::DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
   assert( displayGeometry != NULL );
 
 
   // Apply visual appearance properties from the PropertyList
   ApplyColorAndOpacityProperties( renderer );
 
   // Enable line antialiasing
   glEnable( GL_LINE_SMOOTH );
   glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
   glEnable(GL_DEPTH_TEST);
 
   // Get properties from node (if present)
   const mitk::DataNode* node=this->GetDataNode();
   this->InitializePlanarFigurePropertiesFromDataNode( node );
 
   PlanarFigureDisplayMode lineDisplayMode = PF_DEFAULT;
 
   if ( m_IsSelected )
   {
     lineDisplayMode = PF_SELECTED;
   }
   else if ( m_IsHovering )
   {
     lineDisplayMode = PF_HOVER;
   }
 
   mitk::Point2D anchorPoint; anchorPoint[0] = 0; anchorPoint[1] = 1;
 
   // render the actual lines of the PlanarFigure
-  RenderLines(lineDisplayMode, planarFigure, anchorPoint, planarFigureGeometry2D, rendererGeometry2D, displayGeometry);
+  RenderLines(lineDisplayMode, planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, displayGeometry);
 
   // position-offset of the annotations, is set in RenderAnnotations() and
   // used in RenderQuantities()
   double annotationOffset = 0.0;
 
   //Get Global Opacity
   float globalOpacity = 1.0;
   node->GetFloatProperty("opacity", globalOpacity);
 
   // draw name near the anchor point (point located on the right)
   std::string name = node->GetName();
   if ( m_DrawName && !name.empty() )
   {
     RenderAnnotations(renderer, name, anchorPoint, globalOpacity, lineDisplayMode, annotationOffset);
   }
 
   // draw feature quantities (if requested) next to the anchor point,
   // but under the name (that is where 'annotationOffset' is used)
   if ( m_DrawQuantities )
   {
     RenderQuantities(planarFigure, renderer, anchorPoint, annotationOffset, globalOpacity, lineDisplayMode);
   }
 
   if ( m_DrawControlPoints )
   {
     // draw the control-points
-    RenderControlPoints(planarFigure, lineDisplayMode, planarFigureGeometry2D, rendererGeometry2D, displayGeometry);
+    RenderControlPoints(planarFigure, lineDisplayMode, planarFigurePlaneGeometry, rendererPlaneGeometry, displayGeometry);
   }
 
   glLineWidth( 1.0f );
 }
 
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(
   mitk::PlanarFigure::PolyLineType vertices,
   bool closed,
   Point2D& anchorPoint,
-  const PlaneGeometry* planarFigureGeometry2D,
-  const PlaneGeometry* rendererGeometry2D,
+  const PlaneGeometry* planarFigurePlaneGeometry,
+  const PlaneGeometry* rendererPlaneGeometry,
   const DisplayGeometry* displayGeometry)
 {
   mitk::Point2D rightMostPoint;
   rightMostPoint.Fill( itk::NumericTraits<float>::min() );
 
   // transform all vertices into Point2Ds in display-Coordinates and store them in vector
   std::vector<mitk::Point2D> pointlist;
   for ( PlanarFigure::PolyLineType::iterator iter = vertices.begin(); iter!=vertices.end(); iter++ )
   {
     // Draw this 2D point as OpenGL vertex
     mitk::Point2D displayPoint;
     this->TransformObjectToDisplay( iter->Point, displayPoint,
-      planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
+      planarFigurePlaneGeometry, rendererPlaneGeometry, displayGeometry );
 
     pointlist.push_back(displayPoint);
 
     if ( displayPoint[0] > rightMostPoint[0] )
       rightMostPoint = displayPoint;
   }
 
   // now paint all the points in one run
   std::vector<mitk::Point2D>::iterator pointIter;
 
   if ( closed )
   {
     glBegin( GL_LINE_LOOP );
   }
   else
   {
     glBegin( GL_LINE_STRIP );
   }
 
   for ( pointIter = pointlist.begin(); pointIter!=pointlist.end(); pointIter++ )
   {
     glVertex3f( (*pointIter)[0], (*pointIter)[1], PLANAR_OFFSET );
   }
   glEnd();
 
   anchorPoint = rightMostPoint;
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMainLines(
   mitk::PlanarFigure* figure,
   Point2D& anchorPoint,
-  const PlaneGeometry* planarFigureGeometry2D,
-  const PlaneGeometry* rendererGeometry2D,
+  const PlaneGeometry* planarFigurePlaneGeometry,
+  const PlaneGeometry* rendererPlaneGeometry,
   const DisplayGeometry* displayGeometry)
 {
   unsigned short numberOfPolyLines = figure->GetPolyLinesSize();
   for ( unsigned short loop=0; loop<numberOfPolyLines ; ++loop )
   {
     PlanarFigure::PolyLineType polyline = figure->GetPolyLine(loop);
 
     this->PaintPolyLine( polyline,
       figure->IsClosed(),
-      anchorPoint, planarFigureGeometry2D,
-      rendererGeometry2D, displayGeometry );
+      anchorPoint, planarFigurePlaneGeometry,
+      rendererPlaneGeometry, displayGeometry );
   }
 }
 
 void mitk::PlanarFigureMapper2D::DrawHelperLines(
   mitk::PlanarFigure* figure,
   Point2D& anchorPoint,
-  const PlaneGeometry* planarFigureGeometry2D,
-  const PlaneGeometry* rendererGeometry2D,
+  const PlaneGeometry* planarFigurePlaneGeometry,
+  const PlaneGeometry* rendererPlaneGeometry,
   const DisplayGeometry* displayGeometry)
 {
   unsigned short numberOfHelperPolyLines = figure->GetHelperPolyLinesSize();
 
   // Draw helper objects
   for ( unsigned int loop=0; loop<numberOfHelperPolyLines; ++loop )
   {
     const mitk::PlanarFigure::PolyLineType helperPolyLine = figure->GetHelperPolyLine(loop,
       displayGeometry->GetScaleFactorMMPerDisplayUnit(),
       displayGeometry->GetDisplayHeight() );
 
     // Check if the current helper objects is to be painted
     if ( !figure->IsHelperToBePainted( loop ) )
     {
       continue;
     }
 
     // ... and once normally above the shadow.
     this->PaintPolyLine( helperPolyLine, false,
-      anchorPoint, planarFigureGeometry2D,
-      rendererGeometry2D, displayGeometry );
+      anchorPoint, planarFigurePlaneGeometry,
+      rendererPlaneGeometry, displayGeometry );
   }
 }
 
 
 
 void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::PlaneGeometry *objectGeometry,
   const mitk::PlaneGeometry *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // Project 3D world point onto display geometry
   rendererGeometry->Map( point3D, displayPoint );
   displayGeometry->WorldToDisplay( displayPoint, displayPoint );
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMarker(
   const mitk::Point2D &point,
   float* lineColor,
   float lineOpacity,
   float* markerColor,
   float markerOpacity,
   float lineWidth,
   PlanarFigureControlPointStyleProperty::Shape shape,
   const mitk::PlaneGeometry *objectGeometry,
   const mitk::PlaneGeometry *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point2D displayPoint;
 
   if ( markerOpacity == 0 && lineOpacity == 0 )
     return;
 
   this->TransformObjectToDisplay(
     point, displayPoint,
     objectGeometry, rendererGeometry, displayGeometry );
 
   glColor4f( markerColor[0], markerColor[1], markerColor[2], markerOpacity );
   glLineWidth( lineWidth );
 
   switch ( shape )
   {
   case PlanarFigureControlPointStyleProperty::Square:
   default:
     {
       // Paint filled square
 
       // Disable line antialiasing (does not look nice for squares)
       glDisable( GL_LINE_SMOOTH );
       if ( markerOpacity > 0 )
       {
         glRectf(
           displayPoint[0] - 4, displayPoint[1] - 4,
           displayPoint[0] + 4, displayPoint[1] + 4 );
       }
       // Paint outline
       glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
       glBegin( GL_LINE_LOOP );
       glVertex3f( displayPoint[0] - 4, displayPoint[1] - 4, PLANAR_OFFSET );
       glVertex3f( displayPoint[0] - 4, displayPoint[1] + 4, PLANAR_OFFSET );
       glVertex3f( displayPoint[0] + 4, displayPoint[1] + 4, PLANAR_OFFSET );
       glVertex3f( displayPoint[0] + 4, displayPoint[1] - 4, PLANAR_OFFSET );
       glEnd();
       break;
     }
 
   case PlanarFigureControlPointStyleProperty::Circle:
     {
       float radius = 4.0;
 
       if ( markerOpacity > 0 )
       {
         // Paint filled circle
         glBegin( GL_POLYGON );
         for ( int angle = 0; angle < 8; ++angle )
         {
           float angleRad = angle * (float) 3.14159 / 4.0;
           float x = displayPoint[0] + radius * (float)cos( angleRad );
           float y = displayPoint[1] + radius * (float)sin( angleRad );
           glVertex3f(x, y, PLANAR_OFFSET);
         }
         glEnd();
       }
 
       // Paint outline
       glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
       glBegin( GL_LINE_LOOP );
       for ( int angle = 0; angle < 8; ++angle )
       {
         float angleRad = angle * (float) 3.14159 / 4.0;
         float x = displayPoint[0] + radius * (float)cos( angleRad );
         float y = displayPoint[1] + radius * (float)sin( angleRad );
         glVertex3f(x, y, PLANAR_OFFSET);
       }
       glEnd();
       break;
     }
 
   } // end switch
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
 {
   m_IsSelected = false;
   m_IsHovering = false;
   m_DrawOutline = false;
   m_DrawQuantities = false;
   m_DrawShadow = false;
   m_DrawControlPoints = false;
   m_DrawName = true;
   m_DrawDashed = false;
   m_DrawHelperDashed = false;
 
   m_ShadowWidthFactor = 1.2;
   m_LineWidth = 1.0;
   m_OutlineWidth = 4.0;
   m_HelperlineWidth = 2.0;
 
   m_ControlPointShape = PlanarFigureControlPointStyleProperty::Square;
 
   this->SetColorProperty( m_LineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_LineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_DEFAULT, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_DEFAULT, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_DEFAULT, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_DEFAULT, 0.0 );
 
   this->SetColorProperty( m_LineColor, PF_HOVER, 1.0, 0.7, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_HOVER, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_HOVER, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_HOVER, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_HOVER, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_HOVER, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_HOVER, 0.2 );
 
   this->SetColorProperty( m_LineColor, PF_SELECTED, 1.0, 0.0, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_SELECTED, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_SELECTED, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_SELECTED, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_SELECTED, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_SELECTED, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_SELECTED, 1.0 );
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node )
 {
   if ( node == NULL )
   {
     return;
   }
 
   // if we have not added an observer for ModifiedEvents on the DataNode,
   // we add one now.
   if ( !m_NodeModifiedObserverAdded )
   {
     itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::Pointer nodeModifiedCommand = itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::New();
     nodeModifiedCommand->SetCallbackFunction(this, &mitk::PlanarFigureMapper2D::OnNodeModified);
     m_NodeModifiedObserverTag = node->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
     m_NodeModifiedObserverAdded = true;
   }
 
   // If the DataNode has not been modified since the last execution of
   // this method, we do not run it now.
   if ( !m_NodeModified )
     return;
 
   // Mark the current properties as unmodified
   m_NodeModified = false;
 
   //Get Global Opacity
   float globalOpacity = 1.0;
   node->GetFloatProperty("opacity", globalOpacity);
 
   node->GetBoolProperty( "selected", m_IsSelected );
   node->GetBoolProperty( "planarfigure.ishovering", m_IsHovering );
   node->GetBoolProperty( "planarfigure.drawoutline", m_DrawOutline );
   node->GetBoolProperty( "planarfigure.drawshadow", m_DrawShadow );
   node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
   node->GetBoolProperty( "planarfigure.drawcontrolpoints", m_DrawControlPoints );
   node->GetBoolProperty( "planarfigure.drawname", m_DrawName );
 
   node->GetBoolProperty( "planarfigure.drawdashed", m_DrawDashed );
   node->GetBoolProperty( "planarfigure.helperline.drawdashed", m_DrawHelperDashed );
 
   node->GetFloatProperty( "planarfigure.line.width", m_LineWidth );
   node->GetFloatProperty( "planarfigure.shadow.widthmodifier", m_ShadowWidthFactor );
   node->GetFloatProperty( "planarfigure.outline.width", m_OutlineWidth );
   node->GetFloatProperty( "planarfigure.helperline.width", m_HelperlineWidth );
 
   PlanarFigureControlPointStyleProperty::Pointer styleProperty =
     dynamic_cast< PlanarFigureControlPointStyleProperty* >( node->GetProperty( "planarfigure.controlpointshape" ) );
   if ( styleProperty.IsNotNull() )
   {
     m_ControlPointShape = styleProperty->GetShape();
   }
 
   //Set default color and opacity
   //If property "planarfigure.default.*.color" exists, then use that color. Otherwise global "color" property is used.
   if( !node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color"))
   {
     node->GetColor( m_LineColor[PF_DEFAULT], NULL, "color" );
   }
   node->GetFloatProperty( "planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT] );
 
   if( !node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color"))
   {
     node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "color" );
   }
   node->GetFloatProperty( "planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT] );
 
   if( !node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color"))
   {
     node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "color" );
   }
   node->GetFloatProperty( "planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT] );
 
   node->GetColor( m_MarkerlineColor[PF_DEFAULT], NULL, "planarfigure.default.markerline.color" );
   node->GetFloatProperty( "planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT] );
   node->GetColor( m_MarkerColor[PF_DEFAULT], NULL, "planarfigure.default.marker.color" );
   node->GetFloatProperty( "planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT] );
 
   //Set hover color and opacity
   node->GetColor( m_LineColor[PF_HOVER], NULL, "planarfigure.hover.line.color" );
   node->GetFloatProperty( "planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER] );
   node->GetColor( m_OutlineColor[PF_HOVER], NULL, "planarfigure.hover.outline.color" );
   node->GetFloatProperty( "planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER] );
   node->GetColor( m_HelperlineColor[PF_HOVER], NULL, "planarfigure.hover.helperline.color" );
   node->GetFloatProperty( "planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerlineColor[PF_HOVER], NULL, "planarfigure.hover.markerline.color" );
   node->GetFloatProperty( "planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerColor[PF_HOVER], NULL, "planarfigure.hover.marker.color" );
   node->GetFloatProperty( "planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER] );
 
   //Set selected color and opacity
   node->GetColor( m_LineColor[PF_SELECTED], NULL, "planarfigure.selected.line.color" );
   node->GetFloatProperty( "planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED] );
   node->GetColor( m_OutlineColor[PF_SELECTED], NULL, "planarfigure.selected.outline.color" );
   node->GetFloatProperty( "planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED] );
   node->GetColor( m_HelperlineColor[PF_SELECTED], NULL, "planarfigure.selected.helperline.color" );
   node->GetFloatProperty( "planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerlineColor[PF_SELECTED], NULL, "planarfigure.selected.markerline.color" );
   node->GetFloatProperty( "planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerColor[PF_SELECTED], NULL, "planarfigure.selected.marker.color" );
   node->GetFloatProperty( "planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED] );
 
   //adapt opacity values to global "opacity" property
   for( unsigned int i = 0; i < PF_COUNT; ++i )
   {
     m_LineOpacity[i] *= globalOpacity;
     m_OutlineOpacity[i] *= globalOpacity;
     m_HelperlineOpacity[i] *= globalOpacity;
     m_MarkerlineOpacity[i] *= globalOpacity;
     m_MarkerOpacity[i] *= globalOpacity;
   }
 
 }
 
 void mitk::PlanarFigureMapper2D::OnNodeModified()
 {
   m_NodeModified = true;
 }
 
 void mitk::PlanarFigureMapper2D::SetDefaultProperties( mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite )
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
 
   //node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   node->AddProperty("planarfigure.isextendable",mitk::BoolProperty::New(false));
   //node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(false) );
   //node->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawcontrolpoints", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawname", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawdashed", mitk::BoolProperty::New(false) );
   node->AddProperty( "planarfigure.helperline.drawdashed", mitk::BoolProperty::New(false) );
 
   node->AddProperty("planarfigure.line.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.helperline.width", mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(1.0));
 }
 
 
 void mitk::PlanarFigureMapper2D::RenderControlPoints( mitk::PlanarFigure * planarFigure,
                                                       PlanarFigureDisplayMode lineDisplayMode,
-                                                      mitk::PlaneGeometry * planarFigureGeometry2D,
-                                                      const mitk::PlaneGeometry * rendererGeometry2D,
+                                                      mitk::PlaneGeometry * planarFigurePlaneGeometry,
+                                                      const mitk::PlaneGeometry * rendererPlaneGeometry,
                                                       mitk::DisplayGeometry * displayGeometry )
 {
   bool isEditable = true;
   m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
   PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
 
 
   unsigned int selectedControlPointsIdx = (unsigned int) planarFigure->GetSelectedControlPoint();
   unsigned int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
   // Draw markers at control points (selected control point will be colored)
   for ( unsigned int i = 0; i < numberOfControlPoints ; ++i )
   {
     // Only if planar figure is marked as editable: display markers (control points) in a
     // different style if mouse is over them or they are selected
     if ( isEditable )
     {
       if ( i == selectedControlPointsIdx )
       {
         pointDisplayMode = PF_SELECTED;
       }
       else if ( m_IsHovering && isEditable )
       {
         pointDisplayMode = PF_HOVER;
       }
     }
 
     if ( m_MarkerOpacity[pointDisplayMode] == 0
       && m_MarkerlineOpacity[pointDisplayMode] == 0 )
     {
       continue;
     }
 
     if ( m_DrawOutline )
     {
       // draw outlines for markers as well
       // linewidth for the contour is only half, as full width looks
       // much too thick!
       this->DrawMarker( planarFigure->GetControlPoint( i ),
         m_OutlineColor[lineDisplayMode],
         m_MarkerlineOpacity[pointDisplayMode],
         m_OutlineColor[lineDisplayMode],
         m_MarkerOpacity[pointDisplayMode],
         m_OutlineWidth/2,
         m_ControlPointShape,
-        planarFigureGeometry2D,
-        rendererGeometry2D,
+        planarFigurePlaneGeometry,
+        rendererPlaneGeometry,
         displayGeometry );
     }
 
     this->DrawMarker( planarFigure->GetControlPoint( i ),
       m_MarkerlineColor[pointDisplayMode],
       m_MarkerlineOpacity[pointDisplayMode],
       m_MarkerColor[pointDisplayMode],
       m_MarkerOpacity[pointDisplayMode],
       m_LineWidth,
       m_ControlPointShape,
-      planarFigureGeometry2D,
-      rendererGeometry2D,
+      planarFigurePlaneGeometry,
+      rendererPlaneGeometry,
       displayGeometry );
   }
 
   if ( planarFigure->IsPreviewControlPointVisible() )
   {
     this->DrawMarker( planarFigure->GetPreviewControlPoint(),
       m_MarkerlineColor[PF_HOVER],
       m_MarkerlineOpacity[PF_HOVER],
       m_MarkerColor[PF_HOVER],
       m_MarkerOpacity[PF_HOVER],
       m_LineWidth,
       m_ControlPointShape,
-      planarFigureGeometry2D,
-      rendererGeometry2D,
+      planarFigurePlaneGeometry,
+      rendererPlaneGeometry,
       displayGeometry
       );
   }
 }
 
 void mitk::PlanarFigureMapper2D::RenderAnnotations( mitk::BaseRenderer * renderer,
                                                     std::string name,
                                                     mitk::Point2D anchorPoint,
                                                     float globalOpacity,
                                                     PlanarFigureDisplayMode lineDisplayMode,
                                                     double &annotationOffset )
 {
   mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
   if ( openGLrenderer )
   {
     openGLrenderer->WriteSimpleText( name,
       anchorPoint[0] + 6.0, anchorPoint[1] + 4.0,
       0,
       0,
       0,
       globalOpacity ); //this is a shadow
 
     openGLrenderer->WriteSimpleText( name,
       anchorPoint[0] + 5.0, anchorPoint[1] + 5.0,
       m_LineColor[lineDisplayMode][0],
       m_LineColor[lineDisplayMode][1],
       m_LineColor[lineDisplayMode][2],
       globalOpacity );
 
     // If drawing is successful, add approximate height to annotation offset
     annotationOffset -= 15.0;
   }
 }
 
 void mitk::PlanarFigureMapper2D::RenderQuantities( mitk::PlanarFigure * planarFigure,
                                                    mitk::BaseRenderer * renderer,
                                                    mitk::Point2D anchorPoint,
                                                    double &annotationOffset,
                                                    float globalOpacity,
                                                    PlanarFigureDisplayMode lineDisplayMode )
 {
   std::stringstream quantityString;
   quantityString.setf( ios::fixed, ios::floatfield );
   quantityString.precision( 1 );
 
   bool firstActiveFeature = true;
   for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
   {
     if( planarFigure->IsFeatureActive(i) && planarFigure->IsFeatureVisible( i ) )
     {
       if ( ! firstActiveFeature )
       {
         quantityString << " x ";
       }
       quantityString << planarFigure->GetQuantity( i ) << " ";
       quantityString << planarFigure->GetFeatureUnit( i );
       firstActiveFeature = false;
     }
   }
 
   mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
   if ( openGLrenderer )
   {
     openGLrenderer->WriteSimpleText( quantityString.str().c_str(),
       anchorPoint[0] + 6.0, anchorPoint[1] + 4.0 + annotationOffset,
       0,
       0,
       0,
       globalOpacity ); //this is a shadow
 
     openGLrenderer->WriteSimpleText( quantityString.str().c_str(),
       anchorPoint[0] + 5.0, anchorPoint[1] + 5.0 + annotationOffset,
       m_LineColor[lineDisplayMode][0],
       m_LineColor[lineDisplayMode][1],
       m_LineColor[lineDisplayMode][2],
       globalOpacity );
 
     // If drawing is successful, add approximate height to annotation offset
     annotationOffset -= 15.0;
   }
 }
 
 void mitk::PlanarFigureMapper2D::RenderLines( PlanarFigureDisplayMode lineDisplayMode,
                                               mitk::PlanarFigure * planarFigure,
                                               mitk::Point2D &anchorPoint,
-                                              mitk::PlaneGeometry * planarFigureGeometry2D,
-                                              const mitk::PlaneGeometry * rendererGeometry2D,
+                                              mitk::PlaneGeometry * planarFigurePlaneGeometry,
+                                              const mitk::PlaneGeometry * rendererPlaneGeometry,
                                               mitk::DisplayGeometry * displayGeometry )
 {
   glLineStipple(1, 0x00FF);
 
   // If we want to draw an outline, we do it here
   if ( m_DrawOutline )
   {
     float* color = m_OutlineColor[lineDisplayMode];
     float opacity = m_OutlineOpacity[lineDisplayMode];
 
     // convert to a float array that also contains opacity, faster GL
     float* colorVector = new float[4];
     colorVector[0] = color[0];
     colorVector[1] = color[1];
     colorVector[2] = color[2];
     colorVector[3] = opacity;
 
     // set the color and opacity here as it is common for all outlines
     glColor4fv( colorVector );
     glLineWidth(m_OutlineWidth);
 
     if (m_DrawDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
                          anchorPoint,
-                         planarFigureGeometry2D,
-                         rendererGeometry2D,
+                         planarFigurePlaneGeometry,
+                         rendererPlaneGeometry,
                          displayGeometry );
 
     glLineWidth( m_HelperlineWidth );
 
     if (m_DrawHelperDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
                            anchorPoint,
-                           planarFigureGeometry2D,
-                           rendererGeometry2D,
+                           planarFigurePlaneGeometry,
+                           rendererPlaneGeometry,
                            displayGeometry );
 
     // cleanup
     delete[] colorVector;
   }
 
   // If we want to draw a shadow, we do it here
   if ( m_DrawShadow )
   {
     // determine the shadow opacity
     float opacity = m_OutlineOpacity[lineDisplayMode];
     float shadowOpacity = 0.0f;
     if( opacity > 0.2f )
       shadowOpacity = opacity - 0.2f;
 
     // convert to a float array that also contains opacity, faster GL
     float* shadow = new float[4];
     shadow[0] = 0;
     shadow[1] = 0;
     shadow[2] = 0;
     shadow[3] = shadowOpacity;
 
     // set the color and opacity here as it is common for all shadows
     glColor4fv( shadow );
     glLineWidth( m_OutlineWidth * m_ShadowWidthFactor );
 
     if (m_DrawDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
                          anchorPoint,
-                         planarFigureGeometry2D,
-                         rendererGeometry2D,
+                         planarFigurePlaneGeometry,
+                         rendererPlaneGeometry,
                          displayGeometry );
 
     glLineWidth( m_HelperlineWidth );
 
     if (m_DrawHelperDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
                            anchorPoint,
-                           planarFigureGeometry2D,
-                           rendererGeometry2D,
+                           planarFigurePlaneGeometry,
+                           rendererPlaneGeometry,
                            displayGeometry );
 
     // cleanup
     delete[] shadow;
   }
 
   // set this in brackets to avoid duplicate variables in the same scope
   {
     float* color = m_LineColor[lineDisplayMode];
     float opacity = m_LineOpacity[lineDisplayMode];
 
     // convert to a float array that also contains opacity, faster GL
     float* colorVector = new float[4];
     colorVector[0] = color[0];
     colorVector[1] = color[1];
     colorVector[2] = color[2];
     colorVector[3] = opacity;
 
     // set the color and opacity here as it is common for all mainlines
     glColor4fv( colorVector );
     glLineWidth( m_LineWidth );
 
     if (m_DrawDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the main line for all polylines
     this->DrawMainLines( planarFigure,
       anchorPoint,
-      planarFigureGeometry2D,
-      rendererGeometry2D,
+      planarFigurePlaneGeometry,
+      rendererPlaneGeometry,
       displayGeometry );
 
 
     float* helperColor = m_HelperlineColor[lineDisplayMode];
     float helperOpacity = m_HelperlineOpacity[lineDisplayMode];
     // convert to a float array that also contains opacity, faster GL
     float* helperColorVector = new float[4];
     helperColorVector[0] = helperColor[0];
     helperColorVector[1] = helperColor[1];
     helperColorVector[2] = helperColor[2];
     helperColorVector[3] = helperOpacity;
 
     // we only set the color for the helperlines as the linewidth is unchanged
     glColor4fv( helperColorVector );
 
     glLineWidth( m_HelperlineWidth );
 
     if (m_DrawHelperDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw helper objects
     this->DrawHelperLines( planarFigure,
       anchorPoint,
-      planarFigureGeometry2D,
-      rendererGeometry2D,
+      planarFigurePlaneGeometry,
+      rendererPlaneGeometry,
       displayGeometry );
 
     // cleanup
     delete[] colorVector;
     delete[] helperColorVector;
   }
 
   if ( m_DrawDashed || m_DrawHelperDashed )
     glDisable(GL_LINE_STIPPLE);
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
index ae59d2b794..0ed01fe74e 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
@@ -1,309 +1,309 @@
 /*===================================================================
 
 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_PLANAR_FIGURE_MAPPER_2D_H_
 #define MITK_PLANAR_FIGURE_MAPPER_2D_H_
 
 #include "mitkCommon.h"
 #include <MitkPlanarFigureExports.h>
 #include "mitkGLMapper.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarFigureControlPointStyleProperty.h"
 
 namespace mitk {
 
 class BaseRenderer;
 class Contour;
 
 
 /**
 * \brief OpenGL-based mapper to render display sub-class instances of mitk::PlanarFigure
 *
 * The appearance of planar figures can be configured through  properties. If no properties are specified,
 * default values will be used. There are four elements a planar figure consists of:
 *
 * <ol>
 * <li>"line": the main line segments of the planar figure (note: text is drawn in the same style)
 * <li>"helperline": additional line segments of planar figures, such as arrow tips, arches of angles, etc.
 * <li>"outline": background which is drawn behind the lines and helperlines of the planar figure (optional)
 * <li>"marker": the markers (control points) of a planar figure
 * <li>"markerline": the lines by which markers (control points) are surrounded
 * </ol>
 *
 * In the following, all appearance-related planar figure properties are listed:
 *
 * <ol>
 * <li>General properties for the planar figure
 *   <ul>
 *     <li>"planarfigure.drawoutline": if true, the "outline" lines is drawn
 *     <li>"planarfigure.drawquantities": if true, the quantities (text) associated with the planar figure is drawn
 *     <li>"planarfigure.drawname": if true, the name specified by the dataNode is drawn
 *     <li>"planarfigure.drawshadow": if true, a black shadow is drawn around the planar figure
 *     <li>"planarfigure.controlpointshape": style of the control points (enum)
 *   </ul>
 * <li>Line widths of planar figure elements
 *   <ul>
 *     <li>"planarfigure.line.width": width of "line" segments (float value, in mm)
 *     <li>"planarfigure.shadow.widthmodifier": the width of the shadow is defined by width of the "line" * this modifier
 *     <li>"planarfigure.outline.width": width of "outline" segments (float value, in mm)
 *     <li>"planarfigure.helperline.width": width of "helperline" segments (float value, in mm)
 *   </ul>
 * <li>Color/opacity of planar figure elements in normal mode (unselected)
 *   <ul>
 *     <li>"planarfigure.default.line.color"
 *     <li>"planarfigure.default.line.opacity"
 *     <li>"planarfigure.default.outline.color"
 *     <li>"planarfigure.default.outline.opacity"
 *     <li>"planarfigure.default.helperline.color"
 *     <li>"planarfigure.default.helperline.opacity"
 *     <li>"planarfigure.default.markerline.color"
 *     <li>"planarfigure.default.markerline.opacity"
 *     <li>"planarfigure.default.marker.color"
 *     <li>"planarfigure.default.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in hover mode (mouse-over)
 *   <ul>
 *     <li>"planarfigure.hover.line.color"
 *     <li>"planarfigure.hover.line.opacity"
 *     <li>"planarfigure.hover.outline.color"
 *     <li>"planarfigure.hover.outline.opacity"
 *     <li>"planarfigure.hover.helperline.color"
 *     <li>"planarfigure.hover.helperline.opacity"
 *     <li>"planarfigure.hover.markerline.color"
 *     <li>"planarfigure.hover.markerline.opacity"
 *     <li>"planarfigure.hover.marker.color"
 *     <li>"planarfigure.hover.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in selected mode
 *   <ul>
 *     <li>"planarfigure.selected.line.color"
 *     <li>"planarfigure.selected.line.opacity"
 *     <li>"planarfigure.selected.outline.color"
 *     <li>"planarfigure.selected.outline.opacity"
 *     <li>"planarfigure.selected.helperline.color"
 *     <li>"planarfigure.selected.helperline.opacity"
 *     <li>"planarfigure.selected.markerline.color;"
 *     <li>"planarfigure.selected.markerline.opacity"
 *     <li>"planarfigure.selected.marker.color"
 *     <li>"planarfigure.selected.marker.opacity"
 *   </ul>
 * </ol>
 *
 * \ingroup Mapper
 */
 
 class MitkPlanarFigure_EXPORT PlanarFigureMapper2D : public GLMapper
 {
 public:
 
   mitkClassMacro(PlanarFigureMapper2D, GLMapper);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /**
   * reimplemented from Baseclass
   */
   virtual void Paint(BaseRenderer * renderer);
 
 
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
 
 protected:
 
   enum PlanarFigureDisplayMode
   {
     PF_DEFAULT = 0,
     PF_HOVER = 1,
     PF_SELECTED = 2,
 
     PF_COUNT = 3 //helper variable
   };
 
   PlanarFigureMapper2D();
 
   virtual ~PlanarFigureMapper2D();
 
   /**
   * \brief Renders all the lines defined by the PlanarFigure.
   *
   * This method renders all the lines that are defined by the PlanarFigure.
   * That includes the mainlines and helperlines as well as their shadows
   * and the outlines.
   *
   * This method already takes responsibility for the setting of the relevant
   * openGL attributes to reduce unnecessary setting of these attributes.
   * (e.g. no need to set color twice if it's the same)
   */
   void RenderLines( PlanarFigureDisplayMode lineDisplayMode,
                     mitk::PlanarFigure * planarFigure,
                     mitk::Point2D &anchorPoint,
-                    mitk::PlaneGeometry * planarFigureGeometry2D,
-                    const mitk::PlaneGeometry * rendererGeometry2D,
+                    mitk::PlaneGeometry * planarFigurePlaneGeometry,
+                    const mitk::PlaneGeometry * rendererPlaneGeometry,
                     mitk::DisplayGeometry * displayGeometry );
 
   /**
   * \brief Renders the quantities of the figure below the text annotations.
   */
   void RenderQuantities( mitk::PlanarFigure * planarFigure,
                          mitk::BaseRenderer * renderer,
                          mitk::Point2D anchorPoint,
                          double &annotationOffset,
                          float globalOpacity,
                          PlanarFigureDisplayMode lineDisplayMode );
 
   /**
   * \brief Renders the text annotations.
   */
   void RenderAnnotations( mitk::BaseRenderer * renderer,
                           std::string name,
                           mitk::Point2D anchorPoint,
                           float globalOpacity,
                           PlanarFigureDisplayMode lineDisplayMode,
                           double &annotationOffset );
 
   /**
   * \brief Renders the control-points.
   */
   void RenderControlPoints( mitk::PlanarFigure * planarFigure,
                             PlanarFigureDisplayMode lineDisplayMode,
-                            mitk::PlaneGeometry * planarFigureGeometry2D,
-                            const mitk::PlaneGeometry * rendererGeometry2D,
+                            mitk::PlaneGeometry * planarFigurePlaneGeometry,
+                            const mitk::PlaneGeometry * rendererPlaneGeometry,
                             mitk::DisplayGeometry * displayGeometry );
 
 
   void TransformObjectToDisplay(
     const mitk::Point2D &point2D,
     mitk::Point2D &displayPoint,
     const mitk::PlaneGeometry *objectGeometry,
     const mitk::PlaneGeometry *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void DrawMarker(
     const mitk::Point2D &point,
     float* lineColor,
     float lineOpacity,
     float* markerColor,
     float markerOpacity,
     float lineWidth,
     PlanarFigureControlPointStyleProperty::Shape shape,
     const mitk::PlaneGeometry *objectGeometry,
     const mitk::PlaneGeometry *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   /**
   * \brief Actually paints the polyline defined by the figure.
   */
   void PaintPolyLine( mitk::PlanarFigure::PolyLineType vertices,
     bool closed,
     Point2D& anchorPoint,
-    const PlaneGeometry* planarFigureGeometry2D,
-    const PlaneGeometry* rendererGeometry2D,
+    const PlaneGeometry* planarFigurePlaneGeometry,
+    const PlaneGeometry* rendererPlaneGeometry,
     const DisplayGeometry* displayGeometry);
 
   /**
   * \brief Internally used by RenderLines() to draw the mainlines using
   * PaintPolyLine().
   */
   void DrawMainLines( mitk::PlanarFigure* figure,
     Point2D& anchorPoint,
-    const PlaneGeometry* planarFigureGeometry2D,
-    const PlaneGeometry* rendererGeometry2D,
+    const PlaneGeometry* planarFigurePlaneGeometry,
+    const PlaneGeometry* rendererPlaneGeometry,
     const DisplayGeometry* displayGeometry) ;
 
   /**
   * \brief Internally used by RenderLines() to draw the helperlines using
   * PaintPolyLine().
   */
   void DrawHelperLines( mitk::PlanarFigure* figure,
     Point2D& anchorPoint,
-    const PlaneGeometry* planarFigureGeometry2D,
-    const PlaneGeometry* rendererGeometry2D,
+    const PlaneGeometry* planarFigurePlaneGeometry,
+    const PlaneGeometry* rendererPlaneGeometry,
     const DisplayGeometry* displayGeometry) ;
 
   void InitializeDefaultPlanarFigureProperties();
 
   void InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node );
 
   void SetColorProperty( float property[3][3], PlanarFigureDisplayMode mode, float red, float green, float blue )
   {
     property[mode][0] = red;
     property[mode][1] = green;
     property[mode][2] = blue;
   }
 
   void SetFloatProperty( float* property, PlanarFigureDisplayMode mode, float value )
   {
     property[mode] = value;
   }
 
   /**
   * \brief Callback that sets m_NodeModified to true.
   *
   * This method set the bool flag m_NodeModified to true. It's a callback
   * that is executed when a itk::ModifiedEvet is invoked on our
   * DataNode.
   */
   void OnNodeModified();
 
 private:
   bool m_IsSelected;
   bool m_IsHovering;
   bool m_DrawOutline;
   bool m_DrawQuantities;
   bool m_DrawShadow;
   bool m_DrawControlPoints;
   bool m_DrawName;
   bool m_DrawDashed;
   bool m_DrawHelperDashed;
 
   // the width of the shadow is defined as 'm_LineWidth * m_ShadowWidthFactor'
   float m_LineWidth;
   float m_ShadowWidthFactor;
   float m_OutlineWidth;
   float m_HelperlineWidth;
   //float m_PointWidth;
 
   PlanarFigureControlPointStyleProperty::Shape m_ControlPointShape;
 
   float m_LineColor[3][3];
   float m_LineOpacity[3];
   float m_OutlineColor[3][3];
   float m_OutlineOpacity[3];
   float m_HelperlineColor[3][3];
   float m_HelperlineOpacity[3];
   float m_MarkerlineColor[3][3];
   float m_MarkerlineOpacity[3];
   float m_MarkerColor[3][3];
   float m_MarkerOpacity[3];
 
   // Bool flag that represents whether or not the DataNode has been modified.
   bool m_NodeModified;
 
   // Observer-tag for listening to itk::ModifiedEvents on the DataNode
   unsigned long m_NodeModifiedObserverTag;
 
   // Bool flag that indicates if a node modified observer was added
   bool m_NodeModifiedObserverAdded;
 };
 
 } // namespace mitk
 
 
 
 #endif /* MITK_PLANAR_FIGURE_MAPPER_2D_H_ */
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
index 761030fd15..10f5872f65 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
@@ -1,189 +1,189 @@
 /*===================================================================
 
 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 "mitkPlanarFigureVtkMapper3D.h"
 #include <mitkPlanarFigure.h>
 #include <vtkCellArray.h>
 #include <vtkIdList.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolyLine.h>
 
 mitk::PlanarFigureVtkMapper3D::LocalStorage::LocalStorage()
   : m_Actor(vtkSmartPointer<vtkActor>::New()),
     m_LastMTime(0)
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::LocalStorage::~LocalStorage()
 {
 }
 
 void mitk::PlanarFigureVtkMapper3D::SetDefaultProperties(DataNode*, BaseRenderer*, bool)
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::PlanarFigureVtkMapper3D()
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::~PlanarFigureVtkMapper3D()
 {
 }
 
 void mitk::PlanarFigureVtkMapper3D::ApplyColorAndOpacityProperties(BaseRenderer* renderer, vtkActor* actor)
 {
   if (actor == NULL)
     return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
   bool selected = false;
   dataNode->GetBoolProperty("selected", selected, renderer);
 
   float color[3];
   dataNode->GetColor(color, renderer, selected ? "planarfigure.selected.line.color" : "color");
 
   float opacity = 1.0f;
   dataNode->GetOpacity(opacity, renderer);
 
   vtkProperty* property = actor->GetProperty();
   property->SetColor(color[0], color[1], color[2]);
   property->SetOpacity(opacity);
 }
 
 void mitk::PlanarFigureVtkMapper3D::ApplyPlanarFigureProperties(BaseRenderer* renderer, vtkActor* actor)
 {
   if (actor == NULL)
     return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
   bool render = false;
   dataNode->GetBoolProperty("planarfigure.3drendering", render);
 
   actor->SetVisibility(render);
 
   float lineWidth = 1.0f;
   dataNode->GetFloatProperty("planarfigure.line.width", lineWidth, renderer);
 
   vtkProperty* property = actor->GetProperty();
   property->SetLineWidth(lineWidth);
 }
 
 void mitk::PlanarFigureVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
 {
   typedef PlanarFigure::PolyLineType PolyLine;
 
   DataNode* node = this->GetDataNode();
 
   if (node == NULL)
     return;
 
   PlanarFigure* planarFigure = dynamic_cast<PlanarFigure*>(node->GetData());
 
   if (planarFigure == NULL || !planarFigure->IsPlaced())
     return;
 
   LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
   unsigned long mTime = planarFigure->GetMTime();
 
   if (mTime > localStorage->m_LastMTime)
   {
     localStorage->m_LastMTime = mTime;
 
-    const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(planarFigure->GetGeometry2D());
+    const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(planarFigure->GetPlaneGeometry());
 
     if (planeGeometry == NULL)
       return;
 
     size_t numPolyLines = planarFigure->GetPolyLinesSize();
 
     if (numPolyLines == 0)
       return;
 
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
     vtkIdType baseIndex = 0;
 
     for (size_t i = 0; i < numPolyLines; ++i)
     {
       PolyLine polyLine = planarFigure->GetPolyLine(i);
       vtkIdType numPoints = polyLine.size();
 
       if (numPoints < 2)
         continue;
 
       PolyLine::const_iterator polyLineEnd = polyLine.end();
 
       for (PolyLine::const_iterator polyLineIt = polyLine.begin(); polyLineIt != polyLineEnd; ++polyLineIt)
       {
         Point3D point;
         planeGeometry->Map(polyLineIt->Point, point);
         points->InsertNextPoint(point.GetDataPointer());
       }
 
       vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
 
       vtkIdList* pointIds = line->GetPointIds();
 
       if (planarFigure->IsClosed() && numPoints > 2)
       {
         pointIds->SetNumberOfIds(numPoints + 1);
         pointIds->SetId(numPoints, baseIndex);
       }
       else
       {
         pointIds->SetNumberOfIds(numPoints);
       }
 
       for (vtkIdType j = 0; j < numPoints; ++j)
         pointIds->SetId(j, baseIndex + j);
 
       cells->InsertNextCell(line);
 
       baseIndex += points->GetNumberOfPoints();
     }
 
     vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
     polyData->SetPoints(points);
     polyData->SetLines(cells);
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputData(polyData);
 
     localStorage->m_Actor->SetMapper(mapper);
   }
 
   this->ApplyColorAndOpacityProperties(renderer, localStorage->m_Actor);
   this->ApplyPlanarFigureProperties(renderer, localStorage->m_Actor);
 }
 
 vtkProp* mitk::PlanarFigureVtkMapper3D::GetVtkProp(BaseRenderer* renderer)
 {
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_Actor;
 }
 
 void mitk::PlanarFigureVtkMapper3D::UpdateVtkTransform(BaseRenderer*)
 {
 }
diff --git a/Modules/PlanarFigure/Testing/mitkPlanarArrowTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarArrowTest.cpp
index 12df1bf73e..65f3bf17d7 100644
--- a/Modules/PlanarFigure/Testing/mitkPlanarArrowTest.cpp
+++ b/Modules/PlanarFigure/Testing/mitkPlanarArrowTest.cpp
@@ -1,95 +1,95 @@
 /*===================================================================
 
 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 "mitkPlanarArrow.h"
 #include "mitkPlaneGeometry.h"
 
 
 class mitkPlanarArrowTestClass
 {
 
 public:
 
 
 static void TestPlanarArrowPlacement( mitk::PlanarArrow::Pointer PlanarArrow )
 {
   // Test for correct minimum number of control points in cross-mode
   MITK_TEST_CONDITION( PlanarArrow->GetMinimumNumberOfControlPoints() == 2, "Minimum number of control points" );
 
   // Test for correct maximum number of control points in cross-mode
   MITK_TEST_CONDITION( PlanarArrow->GetMaximumNumberOfControlPoints() == 2, "Maximum number of control points" );
 
   // Initial placement of PlanarArrow
   mitk::Point2D p0;
   p0[0] = 00.0; p0[1] = 0.0;
   PlanarArrow->PlaceFigure( p0 );
 
   // Add second control point
   mitk::Point2D p1;
   p1[0] = 50.0; p1[1] = 00.0;
   PlanarArrow->SetControlPoint(1, p1 );
 
   // Test for number of control points
   MITK_TEST_CONDITION( PlanarArrow->GetNumberOfControlPoints() == 2, "Number of control points after placement" );
 
   // Test for number of polylines
   const mitk::PlanarFigure::PolyLineType polyLine0 = PlanarArrow->GetPolyLine( 0 );
   mitk::PlanarFigure::PolyLineType::const_iterator iter = polyLine0.begin();
   MITK_TEST_CONDITION( PlanarArrow->GetPolyLinesSize() == 1, "Number of polylines after placement" );
 
 
   // Get polylines and check if the generated coordinates are OK
   const mitk::Point2D& pp0 = iter->Point;
   iter++;
   const mitk::Point2D& pp1 = iter->Point;
   MITK_TEST_CONDITION( (pp0 == p0) && (pp1 == p1), "Correct polyline 1" );
 
 
   // Test for number of measurement features
   // none yet
 
 }
 };
 /**
  * mitkPlanarArrowTest tests the methods and behavior of mitk::PlanarArrow with sub-tests:
  *
  * 1. Instantiation and basic tests
  *
  */
 int mitkPlanarArrowTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("PlanarArrow")
 
   // create PlaneGeometry on which to place the PlanarArrow
   mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane( 100.0, 100.0 );
 
   // **************************************************************************
   // 1. Instantiation and basic tests
   mitk::PlanarArrow::Pointer PlanarArrow = mitk::PlanarArrow::New();
-  PlanarArrow->SetGeometry2D( planeGeometry );
+  PlanarArrow->SetPlaneGeometry( planeGeometry );
 
   // first test: did this work?
   MITK_TEST_CONDITION_REQUIRED( PlanarArrow.IsNotNull(), "Testing instantiation" );
 
   // Test placement of PlanarArrow by control points
   mitkPlanarArrowTestClass::TestPlanarArrowPlacement( PlanarArrow );
 
   // always end with this!
   MITK_TEST_END();
 }
diff --git a/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp
index 1a5360da74..b7d804974f 100644
--- a/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp
+++ b/Modules/PlanarFigure/Testing/mitkPlanarCrossTest.cpp
@@ -1,417 +1,417 @@
 /*===================================================================
 
 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 "mitkPlanarCross.h"
 #include "mitkPlaneGeometry.h"
 
 
 class mitkPlanarCrossTestClass
 {
 
 public:
 
 
 static void TestPlanarCrossPlacement( mitk::PlanarCross::Pointer planarCross )
 {
   // Test for correct minimum number of control points in cross-mode
   MITK_TEST_CONDITION( planarCross->GetMinimumNumberOfControlPoints() == 4, "Minimum number of control points" );
 
   // Test for correct maximum number of control points in cross-mode
   MITK_TEST_CONDITION( planarCross->GetMaximumNumberOfControlPoints() == 4, "Maximum number of control points" );
 
   // Initial placement of PlanarCross
   mitk::Point2D p0;
   p0[0] = 20.0; p0[1] = 20.0;
   planarCross->PlaceFigure( p0 );
 
   // Add second control point
   mitk::Point2D p1;
   p1[0] = 80.0; p1[1] = 80.0;
   planarCross->SetCurrentControlPoint( p1 );
 
   // Add third control point
   mitk::Point2D p2;
   p2[0] = 90.0; p2[1] = 10.0;
   planarCross->AddControlPoint( p2 );
 
   // Test if helper polyline is generated
   const mitk::PlanarFigure::PolyLineType helperPolyLine = planarCross->GetHelperPolyLine( 0, 1.0, 100 );
   MITK_TEST_CONDITION( planarCross->GetHelperPolyLinesSize() == 1, "Number of helper polylines after placing 3 points" );
 
   // Test if helper polyline is marked as "to be painted"
   MITK_TEST_CONDITION( planarCross->IsHelperToBePainted( 0 ), "Helper line to be painted after placing 3 points" );
 
   // Test if helper polyline is orthogonal to first line
   mitk::Vector2D v0 = p1 - p0;
   v0.Normalize();
 
   // TODO: make it work again
 
   //mitk::Vector2D hv = helperPolyLine->ElementAt( 1 ) - helperPolyLine->ElementAt( 0 );
   //hv.Normalize();
   //MITK_TEST_CONDITION( fabs(v0 * hv) < mitk::eps, "Helper line is orthogonal to first line" );
 
   //// Test if helper polyline is placed correctly
   //mitk::Vector2D hv1 = helperPolyLine->ElementAt( 1 ) - p2;
   //hv1.Normalize();
   //MITK_TEST_CONDITION( fabs(hv * hv1 - 1.0) < mitk::eps, "Helper line is aligned to third point" );
 
 
   // Add fourth control point
   mitk::Point2D p3;
   p3[0] = 10.0; p3[1] = 90.0;
   planarCross->AddControlPoint( p3 );
 
   // Test for number of control points
   MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 4, "Number of control points after placement" );
 
   // Test if PlanarFigure is closed
   MITK_TEST_CONDITION( !planarCross->IsClosed(), "Is PlanarFigure closed?" );
 
   // Test if helper polyline is no longer marked as "to be painted"
   MITK_TEST_CONDITION( planarCross->IsHelperToBePainted( 0 ), "Helper line no longer to be painted after placement of all 4 points" );
 
 
   // Test for number of polylines
   const mitk::PlanarFigure::PolyLineType polyLine0 = planarCross->GetPolyLine( 0 );
   const mitk::PlanarFigure::PolyLineType polyLine1 = planarCross->GetPolyLine( 1 );
   MITK_TEST_CONDITION( planarCross->GetPolyLinesSize() == 2, "Number of polylines after placement" );
 
   mitk::PlanarFigure::PolyLineType::const_iterator iter0 = polyLine0.begin();
   mitk::PlanarFigure::PolyLineType::const_iterator iter1 = polyLine1.begin();
 
   // Get polylines and check if the generated coordinates are OK
   const mitk::Point2D& pp0 = iter0->Point;
   iter0++;
   const mitk::Point2D& pp1 = iter0->Point;
   MITK_TEST_CONDITION( ((pp0 == p0) && (pp1 == p1))
     || ((pp0 == p1) && (pp1 == p0)), "Correct polyline 1" );
 
   const mitk::Point2D& pp2 = iter1->Point;
   iter1++;
   const mitk::Point2D& pp3 = iter1->Point;
   MITK_TEST_CONDITION( ((pp2 == p2) && (pp3 == p3))
     || ((pp2 == p3) && (pp3 == p2)), "Correct polyline 2" );
 
 
   // Test for number of measurement features
   planarCross->EvaluateFeatures();
   MITK_TEST_CONDITION( planarCross->GetNumberOfFeatures() == 2, "Number of measurement features" );
 
   // Test for correct feature evaluation
   double length0 = sqrt( 80.0 * 80.0 * 2.0 );
   MITK_TEST_CONDITION( fabs( planarCross->GetQuantity( 0 ) - length0) < mitk::eps, "Size of longest diameter" );
 
   double length1 = sqrt( 60.0 * 60.0 * 2.0 );
   MITK_TEST_CONDITION( fabs( planarCross->GetQuantity( 1 ) - length1) < mitk::eps, "Size of short axis diameter" );
 }
 
 
 static void TestPlanarCrossPlacementSingleLine(mitk::PlanarCross::Pointer planarCross)
 {
   // Test for correct minimum number of control points in cross-mode
   MITK_TEST_CONDITION( planarCross->GetMinimumNumberOfControlPoints() == 2, "Minimum number of control points" );
 
   // Test for correct maximum number of control points in cross-mode
   MITK_TEST_CONDITION( planarCross->GetMaximumNumberOfControlPoints() == 2, "Maximum number of control points" );
 
   // Initial placement of PlanarCross
   mitk::Point2D p0;
   p0[0] = 25.0; p0[1] = 10.0;
   planarCross->PlaceFigure( p0 );
 
   // Add second control point
   mitk::Point2D p1;
   p1[0] = 30.0; p1[1] = 60.0;
   planarCross->SetCurrentControlPoint( p1 );
 
   // Verify that no helper line is drawn
   MITK_TEST_CONDITION( planarCross->IsHelperToBePainted( 0 ) == false, "No helper line to be painted in single-line mode" );
 
   // Test for number of control points
   MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Number of control points after placement" );
 
   // Test if PlanarFigure is closed
   MITK_TEST_CONDITION( !planarCross->IsClosed(), "Is PlanarFigure closed?" );
 
 
   // Test for number of polylines
   const mitk::PlanarFigure::PolyLineType polyLine0 = planarCross->GetPolyLine( 0 );
   mitk::PlanarFigure::PolyLineType::const_iterator iter = polyLine0.begin();
   MITK_TEST_CONDITION( planarCross->GetPolyLinesSize() == 1, "Number of polylines after placement" );
 
   // Get polylines and check if the generated coordinates are OK
   const mitk::Point2D& pp0 = iter->Point;
   iter++;
   const mitk::Point2D& pp1 = iter->Point;
   MITK_TEST_CONDITION( ((pp0 == p0) && (pp1 == p1))
     || ((pp0 == p1) && (pp1 == p0)), "Correct polyline 1" );
 
 
   // Test for number of measurement features
   planarCross->EvaluateFeatures();
   MITK_TEST_CONDITION( planarCross->GetNumberOfFeatures() == 1, "Number of measurement features" );
 
   // Test for correct feature evaluation
   double length0 = sqrt( 5.0 * 5.0 + 50.0 * 50.0 );
   MITK_TEST_CONDITION( fabs( planarCross->GetQuantity( 0 ) - length0) < mitk::eps, "Size of diameter" );
 
   // Test if reset called on single-line PlanarCross returns false (nothing to reset)
   MITK_TEST_CONDITION( planarCross->ResetOnPointSelect() == false, "Single-line PlanarCross should not be reset on point edit" );
 }
 
 
 static void TestPlanarCrossPlacementConstrained(mitk::PlanarCross::Pointer planarCross)
 {
   // **************************************************************************
   // Place first control point out of bounds (to the left of the image bounds)
   mitk::Point2D p0;
   p0[0] = -20.0; p0[1] = 20.0;
   planarCross->PlaceFigure( p0 );
 
   // Test if constraint has been applied correctly
   mitk::Point2D cp0 = planarCross->GetControlPoint( 0 );
   MITK_TEST_CONDITION(
        (fabs(cp0[0]) < mitk::eps)
     && (fabs(cp0[1] - 20.0) < mitk::eps), "Point1 placed and constrained correctly" );
 
   // **************************************************************************
   // Add second control point out of bounds (to the top of the image bounds)
   mitk::Point2D p1;
   p1[0] = 80.0; p1[1] = 120.0;
   planarCross->SetCurrentControlPoint( p1 );
 
   // Test if constraint has been applied correctly
   mitk::Point2D cp1 = planarCross->GetControlPoint( 1 );
   MITK_TEST_CONDITION(
     (fabs(cp1[0] - 80.0) < mitk::eps)
     && (fabs(cp1[1] - 100.0) < mitk::eps), "Point2 placed and constrained correctly" );
 
   // **************************************************************************
   // Add third control point out of bounds (outside of channel defined by first line)
   mitk::Point2D p2;
   p2[0] = 100.0; p2[1] = 100.0;
   planarCross->AddControlPoint( p2 );
 
   // Test if constraint has been applied correctly (100.0, 100.0) must be projected to (90.0, 90.0)
   mitk::Point2D cp2 = planarCross->GetControlPoint( 2 );
   MITK_TEST_CONDITION(
     (fabs(cp2[0] - 90.0) < mitk::eps)
     && (fabs(cp2[1] - 90.0) < mitk::eps), "Point3 placed and constrained correctly" );
 
   // Move third control point (within channel defined by first line)
   p2[0] = 40.0; p2[1] = 20.0;
   planarCross->SetControlPoint( 2, p2 );
 
   // Test if point is still at this position (no constrained should be applied)
   cp2 = planarCross->GetControlPoint( 2 );
   MITK_TEST_CONDITION(
     (fabs(cp2[0] - 40.0) < mitk::eps)
     && (fabs(cp2[1] - 20.0) < mitk::eps), "Point3 moved correctly" );
 
   // **************************************************************************
   // Add fourth control point out of bounds (outside of line defined by first line and third point)
   mitk::Point2D p3;
   p3[0] = 20.0; p3[1] = 60.0;
   planarCross->AddControlPoint( p3 );
 
   // Test if constraint has been applied correctly (20.0, 60.0) must be projected to (10.0, 50.0)
   mitk::Point2D cp3 = planarCross->GetControlPoint( 3 );
   MITK_TEST_CONDITION(
     (fabs(cp3[0] - 10.0) < mitk::eps)
     && (fabs(cp3[1] - 50.0) < mitk::eps), "Point4 placed and constrained correctly" );
 
   // Move fourth control point (to a position which would result in two non-intersecting line
   // without the constraint that lines have to intersect)
   p3[0] = 40.0; p3[1] = 30.0;
   planarCross->SetControlPoint( 3, p3 );
 
   // Test if constrained point is on the projected intersection point of both lines (20.0/40.0)
   cp3 = planarCross->GetControlPoint( 3 );
   MITK_TEST_CONDITION(
     (fabs(cp3[0] - 20.0) < mitk::eps)
     && (fabs(cp3[1] - 40.0) < mitk::eps), "Point4 placed and constrained correctly" );
 }
 
 
 static void TestPlanarCrossEdit(mitk::PlanarCross::Pointer planarCross)
 {
   // * point move (different points)
   //   --> reset
   //   --> test which point is where / evaluation
   mitk::Point2D p0 = planarCross->GetControlPoint( 0 );
   mitk::Point2D p1 = planarCross->GetControlPoint( 1 );
   mitk::Point2D p2 = planarCross->GetControlPoint( 2 );
   mitk::Point2D p3 = planarCross->GetControlPoint( 3 );
 
   // **************************************************************************
   // Edit control point 0
   planarCross->SelectControlPoint( 0 );
 
   // Request reset and check if it is done
   MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 0: Double-line PlanarCross should be reset" );
 
   // Check number of control points
   MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" );
 
   // Check if correct control points have been left
   MITK_TEST_CONDITION(
        (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p1 ) < mitk::eps)
     && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p0 ) < mitk::eps),
     "Reset to expected control points (p1, p0)" );
 
   // Reset planar cross to original values
   ResetPlanarCross( planarCross, p0, p1, p2, p3 );
 
 
   // **************************************************************************
   // Edit control point 1
   planarCross->SelectControlPoint( 1 );
 
   // Request reset and check if it is done
   MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 1: Double-line PlanarCross should be reset" );
 
   // Check number of control points
   MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" );
 
   // Check if correct control points have been left
   MITK_TEST_CONDITION(
     (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p0 ) < mitk::eps)
     && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p1 ) < mitk::eps),
     "Reset to expected control points (p0, p1)" );
 
   // Reset planar cross to original values
   ResetPlanarCross( planarCross, p0, p1, p2, p3 );
 
 
   // **************************************************************************
   // Edit control point 2
   planarCross->SelectControlPoint( 2 );
 
   // Request reset and check if it is done
   MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 2: Double-line PlanarCross should be reset" );
 
   // Check number of control points
   MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" );
 
   // Check if correct control points have been left
   MITK_TEST_CONDITION(
     (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p3 ) < mitk::eps)
     && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p2 ) < mitk::eps),
     "Reset to expected control points (p3, p2)" );
 
   // Reset planar cross to original values
   ResetPlanarCross( planarCross, p0, p1, p2, p3 );
 
 
   // **************************************************************************
   // Edit control point 3
   planarCross->SelectControlPoint( 3 );
 
   // Request reset and check if it is done
   MITK_TEST_CONDITION( planarCross->ResetOnPointSelect(), "Editing control point 3: Double-line PlanarCross should be reset" );
 
   // Check number of control points
   MITK_TEST_CONDITION( planarCross->GetNumberOfControlPoints() == 2, "Two control points are left" );
 
   // Check if correct control points have been left
   MITK_TEST_CONDITION(
     (planarCross->GetControlPoint( 0 ).EuclideanDistanceTo( p2 ) < mitk::eps)
     && (planarCross->GetControlPoint( 1 ).EuclideanDistanceTo( p3 ) < mitk::eps),
     "Reset to expected control points (p2, p3)" );
 }
 
 
 static void ResetPlanarCross( mitk::PlanarCross::Pointer planarCross,
   mitk::Point2D p0, mitk::Point2D p1, mitk::Point2D p2, mitk::Point2D p3 )
 {
   planarCross->SetControlPoint( 0, p0, true );
   planarCross->SetControlPoint( 1, p1, true );
   planarCross->SetControlPoint( 2, p2, true );
   planarCross->SetControlPoint( 3, p3, true );
 }
 
 
 };
 
 
 /**
  * mitkPlanarCrossTest tests the methods and behavior of mitk::PlanarCross with four sub-tests:
  *
  * 1. Double-line mode instantiation and basic tests
  * 2. Single-line mode instantiation and basic tests
  * 3. Tests of application of spatial constraints for double-line mode
  * 4. Tests if editing of PlanarCross works as intended
  *
  */
 int mitkPlanarCrossTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("PlanarCross")
 
   // create PlaneGeometry on which to place the PlanarCross
   mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane( 100.0, 100.0 );
 
   // **************************************************************************
   // 1. Double-line mode instantiation and basic tests
   mitk::PlanarCross::Pointer planarCross = mitk::PlanarCross::New();
-  planarCross->SetGeometry2D( planeGeometry );
+  planarCross->SetPlaneGeometry( planeGeometry );
 
   // first test: did this work?
   MITK_TEST_CONDITION_REQUIRED( planarCross.IsNotNull(), "Testing instantiation" );
 
   // test: default cross-mode (not single-line-mode)?
   MITK_TEST_CONDITION_REQUIRED( !planarCross->GetSingleLineMode(), "Testing default cross mode" );
 
 
   // Test placement of PlanarCross by control points
   mitkPlanarCrossTestClass::TestPlanarCrossPlacement( planarCross );
 
 
   // **************************************************************************
   // 2. Single-line mode instantiation and basic tests
   planarCross = mitk::PlanarCross::New();
   planarCross->SingleLineModeOn();
-  planarCross->SetGeometry2D( planeGeometry );
+  planarCross->SetPlaneGeometry( planeGeometry );
 
   // test: single-line mode?
   MITK_TEST_CONDITION_REQUIRED( planarCross->GetSingleLineMode(), "Testing activation of single-line mode" );
 
   // Test placement of single-line PlanarCross by control points
   mitkPlanarCrossTestClass::TestPlanarCrossPlacementSingleLine( planarCross );
 
 
   // **************************************************************************
   // 3. Tests of application of spatial constraints for double-line mode
   planarCross = mitk::PlanarCross::New();
-  planarCross->SetGeometry2D( planeGeometry );
+  planarCross->SetPlaneGeometry( planeGeometry );
 
   // Test placement with various out-of-bounds control points (automatic application of
   // constraints expected)
   mitkPlanarCrossTestClass::TestPlanarCrossPlacementConstrained( planarCross );
 
 
   // **************************************************************************
   // 4. Tests if editing of PlanarCross works as intended
   mitkPlanarCrossTestClass::TestPlanarCrossEdit( planarCross );
 
 
 
   // always end with this!
   MITK_TEST_END()
 }
diff --git a/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp
index 880bdfe77a..a2d73f8dc9 100644
--- a/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp
+++ b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp
@@ -1,603 +1,603 @@
 /*===================================================================
 
 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 "mitkPlanarAngle.h"
 #include "mitkPlanarCircle.h"
 #include "mitkPlanarCross.h"
 #include "mitkPlanarFourPointAngle.h"
 #include "mitkPlanarLine.h"
 #include "mitkPlanarPolygon.h"
 #include "mitkPlanarSubdivisionPolygon.h"
 #include "mitkPlanarRectangle.h"
 
 #include "mitkPlanarFigureWriter.h"
 #include "mitkPlanarFigureReader.h"
 
 #include "mitkPlaneGeometry.h"
 
 #include <itksys/SystemTools.hxx>
 
 static mitk::PlanarFigure::Pointer Clone(mitk::PlanarFigure::Pointer original)
 {
   return original->Clone();
 }
 
 /** \brief Helper class for testing PlanarFigure reader and writer classes. */
 class PlanarFigureIOTestClass
 {
 public:
 
   typedef std::list< mitk::PlanarFigure::Pointer > PlanarFigureList;
   typedef std::vector< mitk::PlanarFigureWriter::Pointer > PlanarFigureToMemoryWriterList;
 
   static PlanarFigureList CreatePlanarFigures()
   {
     PlanarFigureList planarFigures;
 
     // Create PlaneGeometry on which to place the PlanarFigures
     mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
     planeGeometry->InitializeStandardPlane( 100.0, 100.0 );
 
     // Create a few sample points for PlanarFigure placement
     mitk::Point2D p0; p0[0] = 20.0; p0[1] = 20.0;
     mitk::Point2D p1; p1[0] = 80.0; p1[1] = 80.0;
     mitk::Point2D p2; p2[0] = 90.0; p2[1] = 10.0;
     mitk::Point2D p3; p3[0] = 10.0; p3[1] = 90.0;
 
     // Create PlanarAngle
     mitk::PlanarAngle::Pointer planarAngle = mitk::PlanarAngle::New();
-    planarAngle->SetGeometry2D( planeGeometry );
+    planarAngle->SetPlaneGeometry( planeGeometry );
     planarAngle->PlaceFigure( p0 );
     planarAngle->SetCurrentControlPoint( p1 );
     planarAngle->AddControlPoint( p2 );
     planarAngle->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarAngle.GetPointer() );
 
     // Create PlanarCircle
     mitk::PlanarCircle::Pointer planarCircle = mitk::PlanarCircle::New();
-    planarCircle->SetGeometry2D( planeGeometry );
+    planarCircle->SetPlaneGeometry( planeGeometry );
     planarCircle->PlaceFigure( p0 );
     planarCircle->SetCurrentControlPoint( p1 );
     planarCircle->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarCircle.GetPointer() );
 
     // Create PlanarCross
     mitk::PlanarCross::Pointer planarCross = mitk::PlanarCross::New();
     planarCross->SetSingleLineMode( false );
-    planarCross->SetGeometry2D( planeGeometry );
+    planarCross->SetPlaneGeometry( planeGeometry );
     planarCross->PlaceFigure( p0 );
     planarCross->SetCurrentControlPoint( p1 );
     planarCross->AddControlPoint( p2 );
     planarCross->AddControlPoint( p3 );
     planarCross->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarCross.GetPointer() );
 
     // Create PlanarFourPointAngle
     mitk::PlanarFourPointAngle::Pointer planarFourPointAngle = mitk::PlanarFourPointAngle::New();
-    planarFourPointAngle->SetGeometry2D( planeGeometry );
+    planarFourPointAngle->SetPlaneGeometry( planeGeometry );
     planarFourPointAngle->PlaceFigure( p0 );
     planarFourPointAngle->SetCurrentControlPoint( p1 );
     planarFourPointAngle->AddControlPoint( p2 );
     planarFourPointAngle->AddControlPoint( p3 );
     planarFourPointAngle->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarFourPointAngle.GetPointer() );
 
     // Create PlanarLine
     mitk::PlanarLine::Pointer planarLine = mitk::PlanarLine::New();
-    planarLine->SetGeometry2D( planeGeometry );
+    planarLine->SetPlaneGeometry( planeGeometry );
     planarLine->PlaceFigure( p0 );
     planarLine->SetCurrentControlPoint( p1 );
     planarLine->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarLine.GetPointer() );
 
     // Create PlanarPolygon
     mitk::PlanarPolygon::Pointer planarPolygon = mitk::PlanarPolygon::New();
     planarPolygon->SetClosed( false );
-    planarPolygon->SetGeometry2D( planeGeometry );
+    planarPolygon->SetPlaneGeometry( planeGeometry );
     planarPolygon->PlaceFigure( p0 );
     planarPolygon->SetCurrentControlPoint( p1 );
     planarPolygon->AddControlPoint( p2 );
     planarPolygon->AddControlPoint( p3 );
     planarPolygon->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarPolygon.GetPointer() );
 
     // Create PlanarSubdivisionPolygon
     mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygon = mitk::PlanarSubdivisionPolygon::New();
     planarSubdivisionPolygon->SetClosed( false );
-    planarSubdivisionPolygon->SetGeometry2D( planeGeometry );
+    planarSubdivisionPolygon->SetPlaneGeometry( planeGeometry );
     planarSubdivisionPolygon->PlaceFigure( p0 );
     planarSubdivisionPolygon->SetCurrentControlPoint( p1 );
     planarSubdivisionPolygon->AddControlPoint( p2 );
     planarSubdivisionPolygon->AddControlPoint( p3 );
     planarSubdivisionPolygon->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarSubdivisionPolygon.GetPointer() );
 
     // Create PlanarRectangle
     mitk::PlanarRectangle::Pointer planarRectangle = mitk::PlanarRectangle::New();
-    planarRectangle->SetGeometry2D( planeGeometry );
+    planarRectangle->SetPlaneGeometry( planeGeometry );
     planarRectangle->PlaceFigure( p0 );
     planarRectangle->SetCurrentControlPoint( p1 );
     planarRectangle->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarRectangle.GetPointer() );
 
     //create preciseGeometry which is using float coordinates
     mitk::PlaneGeometry::Pointer preciseGeometry = mitk::PlaneGeometry::New();
     mitk::Vector3D right;
     right[0] = 0.0;
     right[1] = 1.23456;
     right[2] = 0.0;
 
     mitk::Vector3D down;
     down[0] = 1.23456;
     down[1] = 0.0;
     down[2] = 0.0;
 
     mitk::Vector3D spacing;
     spacing[0] = 0.0123456;
     spacing[1] = 0.0123456;
     spacing[2] = 1.123456;
     preciseGeometry->InitializeStandardPlane( right, down, &spacing );
 
     //convert points into the precise coordinates
     mitk::Point2D p0precise; p0precise[0] = p0[0] * spacing[0]; p0precise[1] = p0[1] * spacing[1];
     mitk::Point2D p1precise; p1precise[0] = p1[0] * spacing[0]; p1precise[1] = p1[1] * spacing[1];
     mitk::Point2D p2precise; p2precise[0] = p2[0] * spacing[0]; p2precise[1] = p2[1] * spacing[1];
     mitk::Point2D p3precise; p3precise[0] = p3[0] * spacing[0]; p3precise[1] = p3[1] * spacing[1];
 
     //Now all PlanarFigures are create using the precise Geometry
     // Create PlanarCross
     mitk::PlanarCross::Pointer nochncross = mitk::PlanarCross::New();
     nochncross->SetSingleLineMode( false );
-    nochncross->SetGeometry2D( preciseGeometry );
+    nochncross->SetPlaneGeometry( preciseGeometry );
     nochncross->PlaceFigure( p0precise );
     nochncross->SetCurrentControlPoint( p1precise );
     nochncross->AddControlPoint( p2precise );
     nochncross->AddControlPoint( p3precise );
     nochncross->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( nochncross.GetPointer() );
 
     // Create PlanarAngle
     mitk::PlanarAngle::Pointer planarAnglePrecise = mitk::PlanarAngle::New();
-    planarAnglePrecise->SetGeometry2D( preciseGeometry );
+    planarAnglePrecise->SetPlaneGeometry( preciseGeometry );
     planarAnglePrecise->PlaceFigure( p0precise );
     planarAnglePrecise->SetCurrentControlPoint( p1precise );
     planarAnglePrecise->AddControlPoint( p2precise );
     planarAnglePrecise->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarAnglePrecise.GetPointer() );
 
     // Create PlanarCircle
     mitk::PlanarCircle::Pointer planarCirclePrecise = mitk::PlanarCircle::New();
-    planarCirclePrecise->SetGeometry2D( preciseGeometry );
+    planarCirclePrecise->SetPlaneGeometry( preciseGeometry );
     planarCirclePrecise->PlaceFigure( p0precise );
     planarCirclePrecise->SetCurrentControlPoint( p1precise );
     planarCirclePrecise->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarCirclePrecise.GetPointer() );
 
     // Create PlanarFourPointAngle
     mitk::PlanarFourPointAngle::Pointer planarFourPointAnglePrecise = mitk::PlanarFourPointAngle::New();
-    planarFourPointAnglePrecise->SetGeometry2D( preciseGeometry );
+    planarFourPointAnglePrecise->SetPlaneGeometry( preciseGeometry );
     planarFourPointAnglePrecise->PlaceFigure( p0precise );
     planarFourPointAnglePrecise->SetCurrentControlPoint( p1precise );
     planarFourPointAnglePrecise->AddControlPoint( p2precise );
     planarFourPointAnglePrecise->AddControlPoint( p3precise );
     planarFourPointAnglePrecise->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarFourPointAnglePrecise.GetPointer() );
 
     // Create PlanarLine
     mitk::PlanarLine::Pointer planarLinePrecise = mitk::PlanarLine::New();
-    planarLinePrecise->SetGeometry2D( preciseGeometry );
+    planarLinePrecise->SetPlaneGeometry( preciseGeometry );
     planarLinePrecise->PlaceFigure( p0precise );
     planarLinePrecise->SetCurrentControlPoint( p1precise );
     planarLinePrecise->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarLinePrecise.GetPointer() );
 
     // Create PlanarPolygon
     mitk::PlanarPolygon::Pointer planarPolygonPrecise = mitk::PlanarPolygon::New();
     planarPolygonPrecise->SetClosed( false );
-    planarPolygonPrecise->SetGeometry2D( preciseGeometry );
+    planarPolygonPrecise->SetPlaneGeometry( preciseGeometry );
     planarPolygonPrecise->PlaceFigure( p0precise );
     planarPolygonPrecise->SetCurrentControlPoint( p1precise );
     planarPolygonPrecise->AddControlPoint( p2precise );
     planarPolygonPrecise->AddControlPoint( p3precise );
     planarPolygonPrecise->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarPolygonPrecise.GetPointer() );
 
     // Create PlanarSubdivisionPolygon
     mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygonPrecise = mitk::PlanarSubdivisionPolygon::New();
     planarSubdivisionPolygonPrecise->SetClosed( false );
-    planarSubdivisionPolygonPrecise->SetGeometry2D( preciseGeometry );
+    planarSubdivisionPolygonPrecise->SetPlaneGeometry( preciseGeometry );
     planarSubdivisionPolygonPrecise->PlaceFigure( p0precise );
     planarSubdivisionPolygonPrecise->SetCurrentControlPoint( p1precise );
     planarSubdivisionPolygonPrecise->AddControlPoint( p2precise );
     planarSubdivisionPolygonPrecise->AddControlPoint( p3precise );
     planarSubdivisionPolygonPrecise->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarSubdivisionPolygonPrecise.GetPointer() );
 
     // Create PlanarRectangle
     mitk::PlanarRectangle::Pointer planarRectanglePrecise = mitk::PlanarRectangle::New();
-    planarRectanglePrecise->SetGeometry2D( preciseGeometry );
+    planarRectanglePrecise->SetPlaneGeometry( preciseGeometry );
     planarRectanglePrecise->PlaceFigure( p0precise );
     planarRectanglePrecise->SetCurrentControlPoint( p1precise );
     planarRectanglePrecise->GetPropertyList()->SetBoolProperty( "initiallyplaced", true );
     planarFigures.push_back( planarRectanglePrecise.GetPointer() );
 
     return planarFigures;
   }
 
   static PlanarFigureList CreateDeepCopiedPlanarFigures(PlanarFigureList original)
   {
     PlanarFigureList copiedPlanarFigures;
 
     PlanarFigureList::iterator it1;
 
     for ( it1 = original.begin(); it1 != original.end(); ++it1 )
     {
       mitk::PlanarFigure::Pointer copiedFigure = (*it1)->Clone();
 
       copiedPlanarFigures.push_back(copiedFigure);
     }
     return copiedPlanarFigures;
   }
 
   static PlanarFigureList CreateClonedPlanarFigures(PlanarFigureList original)
   {
     PlanarFigureList clonedPlanarFigures;
     clonedPlanarFigures.resize(original.size());
     std::transform(original.begin(), original.end(), clonedPlanarFigures.begin(), Clone);
     return clonedPlanarFigures;
   }
 
   static void VerifyPlanarFigures( PlanarFigureList &planarFigures1, PlanarFigureList &planarFigures2 )
   {
     PlanarFigureList::iterator it1, it2;
 
     int i = 0;
     for ( it1 = planarFigures1.begin(); it1 != planarFigures1.end(); ++it1 )
     {
       bool planarFigureFound = false;
       int j = 0;
       for ( it2 = planarFigures2.begin(); it2 != planarFigures2.end(); ++it2 )
       {
         // Compare PlanarFigures (returns false if different types)
         if ( ComparePlanarFigures( *it1, *it2 ) )
         {
           planarFigureFound = true;
         }
         ++j;
       }
 
       // Test if (at least) on PlanarFigure of the first type was found in the second list
       MITK_TEST_CONDITION_REQUIRED(
           planarFigureFound,
           "Testing if " << (*it1)->GetNameOfClass() << " has a counterpart " << i );
       ++i;
     }
   }
 
   static bool ComparePlanarFigures( mitk::PlanarFigure* figure1, mitk::PlanarFigure* figure2 )
   {
     // Test if PlanarFigures are of same type; otherwise return
     if ( strcmp( figure1->GetNameOfClass(), figure2->GetNameOfClass() ) != 0 )
     {
       return false;
     }
 
     if( strcmp( figure1->GetNameOfClass(), "PlanarCross" ) == 0 )
     {
       std::cout << "Planar Cross Found" << std::endl;
     }
 
     // Test for equal number of control points
     if(figure1->GetNumberOfControlPoints() != figure2->GetNumberOfControlPoints())
     {
       return false;
     }
 
     // Test if all control points are equal
     for ( unsigned int i = 0; i < figure1->GetNumberOfControlPoints(); ++i )
     {
       mitk::Point2D point1 = figure1->GetControlPoint( i );
       mitk::Point2D point2 = figure2->GetControlPoint( i );
 
       if(point1.EuclideanDistanceTo( point2 ) >= mitk::eps)
       {
         return false;
       }
     }
 
     // Test for equal number of properties
     typedef mitk::PropertyList::PropertyMap PropertyMap;
     const PropertyMap* properties1 = figure1->GetPropertyList()->GetMap();
     const PropertyMap* properties2 = figure2->GetPropertyList()->GetMap();
 
     if(properties1->size() != properties2->size())
     {
       return false;
     }
 
     MITK_INFO << "List 1:";
     for (PropertyMap::const_iterator i1 = properties1->begin(); i1 != properties1->end(); ++i1)
     {
       std::cout << i1->first << std::endl;
     }
 
     MITK_INFO << "List 2:";
     for (PropertyMap::const_iterator i2 = properties2->begin(); i2 != properties2->end(); ++i2)
     {
       std::cout << i2->first << std::endl;
     }
 
     MITK_INFO << "-------";
 
     // Test if all properties are equal
     if(!std::equal( properties1->begin(), properties1->end(), properties2->begin(), PropertyMapEntryCompare() ))
     {
       return false;
     }
 
     // Test if Geometry is equal
-    const mitk::PlaneGeometry* planeGeometry1 = dynamic_cast<const mitk::PlaneGeometry*>(figure1->GetGeometry2D());
-    const mitk::PlaneGeometry* planeGeometry2 = dynamic_cast<const mitk::PlaneGeometry*>(figure2->GetGeometry2D());
+    const mitk::PlaneGeometry* planeGeometry1 = dynamic_cast<const mitk::PlaneGeometry*>(figure1->GetPlaneGeometry());
+    const mitk::PlaneGeometry* planeGeometry2 = dynamic_cast<const mitk::PlaneGeometry*>(figure2->GetPlaneGeometry());
 
     // Test Geometry transform parameters
     typedef mitk::Geometry3D::TransformType TransformType;
     const TransformType* affineGeometry1 = planeGeometry1->GetIndexToWorldTransform();
     const TransformType::ParametersType& parameters1 = affineGeometry1->GetParameters();
     const TransformType::ParametersType& parameters2 = planeGeometry2->GetIndexToWorldTransform()->GetParameters();
     for ( unsigned int i = 0; i < affineGeometry1->GetNumberOfParameters(); ++i )
     {
       if ( fabs(parameters1.GetElement( i ) - parameters2.GetElement( i )) >= mitk::eps )
       {
         return false;
       }
     }
 
     // Test Geometry bounds
     typedef mitk::Geometry3D::BoundsArrayType BoundsArrayType;
     const BoundsArrayType& bounds1 = planeGeometry1->GetBounds();
     const BoundsArrayType& bounds2 = planeGeometry2->GetBounds();
     for ( unsigned int i = 0; i < 6; ++i )
     {
       if ( fabs(bounds1.GetElement( i ) - bounds2.GetElement( i )) >= mitk::eps )
       {
         return false;
       };
     }
 
     // Test Geometry spacing and origin
     mitk::Vector3D spacing1 = planeGeometry1->GetSpacing();
     mitk::Vector3D spacing2 = planeGeometry2->GetSpacing();
     if((spacing1 - spacing2).GetNorm() >= mitk::eps)
     {
       return false;
     }
 
     mitk::Point3D origin1 = planeGeometry1->GetOrigin();
     mitk::Point3D origin2 = planeGeometry2->GetOrigin();
 
     if(origin1.EuclideanDistanceTo( origin2 ) >= mitk::eps)
     {
       return false;
     }
     return true;
   }
 
 
   static void SerializePlanarFigures( PlanarFigureList &planarFigures, std::string& fileName )
   {
     //std::string  sceneFileName = Poco::Path::temp() + /*Poco::Path::separator() +*/ "scene.zip";
     std::cout << "File name: " << fileName << std::endl;
 
     mitk::PlanarFigureWriter::Pointer writer = mitk::PlanarFigureWriter::New();
     writer->SetFileName( fileName.c_str() );
 
     unsigned int i;
     PlanarFigureList::iterator it;
     for ( it = planarFigures.begin(), i = 0;
     it != planarFigures.end();
     ++it, ++i )
     {
       writer->SetInput( i, *it );
     }
 
     writer->Update();
 
     MITK_TEST_CONDITION_REQUIRED(
         writer->GetSuccess(),
         "Testing if writing was successful");
   }
 
 
   static PlanarFigureList DeserializePlanarFigures( std::string& fileName)
   {
     // Read in the planar figures
     mitk::PlanarFigureReader::Pointer reader = mitk::PlanarFigureReader::New();
     reader->SetFileName( fileName.c_str() );
     reader->Update();
 
     MITK_TEST_CONDITION_REQUIRED(
         reader->GetSuccess(),
         "Testing if reading was successful");
 
 
     // Store them in the list and return it
     PlanarFigureList planarFigures;
     for ( unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i )
     {
       mitk::PlanarFigure* figure = reader->GetOutput( i );
       planarFigures.push_back( figure );
     }
 
     return planarFigures;
   }
 
 
 
 
   static PlanarFigureToMemoryWriterList SerializePlanarFiguresToMemoryBuffers( PlanarFigureList &planarFigures )
   {
     PlanarFigureToMemoryWriterList pfMemoryWriters;
     unsigned int i;
     PlanarFigureList::iterator it;
 
     bool success = true;
     for ( it = planarFigures.begin(), i = 0;
     it != planarFigures.end();
     ++it, ++i )
     {
       mitk::PlanarFigureWriter::Pointer writer = mitk::PlanarFigureWriter::New();
       writer->SetWriteToMemory( true );
       writer->SetInput( *it );
       writer->Update();
 
       pfMemoryWriters.push_back(writer);
 
       if(!writer->GetSuccess())
         success = false;
     }
 
     MITK_TEST_CONDITION_REQUIRED(success, "Testing if writing to memory buffers was successful");
 
     return pfMemoryWriters;
   }
 
   static PlanarFigureList DeserializePlanarFiguresFromMemoryBuffers( PlanarFigureToMemoryWriterList pfMemoryWriters)
   {
     // Store them in the list and return it
     PlanarFigureList planarFigures;
     bool success = true;
     for ( unsigned int i = 0; i < pfMemoryWriters.size(); ++i )
     {
       // Read in the planar figures
       mitk::PlanarFigureReader::Pointer reader = mitk::PlanarFigureReader::New();
       reader->SetReadFromMemory( true );
       reader->SetMemoryBuffer(pfMemoryWriters[i]->GetMemoryPointer(), pfMemoryWriters[i]->GetMemorySize());
       reader->Update();
       mitk::PlanarFigure* figure = reader->GetOutput( 0 );
       planarFigures.push_back( figure );
 
       if(!reader->GetSuccess())
         success = false;
     }
 
     MITK_TEST_CONDITION_REQUIRED(success, "Testing if reading was successful");
 
     return planarFigures;
   }
 
 
 private:
   class PropertyMapEntryCompare
   {
   public:
     bool operator()(
         const mitk::PropertyList::PropertyMap::value_type &entry1,
         const mitk::PropertyList::PropertyMap::value_type &entry2 )
     {
       MITK_INFO << "Comparing " << entry1.first << "(" << entry1.second->GetValueAsString() << ") and " << entry2.first << "(" << entry2.second->GetValueAsString() << ")";
       // Compare property objects contained in the map entries (see mitk::PropertyList)
       return *(entry1.second) == *(entry2.second);
     }
   };
 
 }; // end test helper class
 
 
 /** \brief Test for PlanarFigure reader and writer classes.
  *
  * The test works as follows:
  *
  * First, a number of PlanarFigure objects of different types are created and placed with
  * various control points. These objects are the serialized to file, read again from file, and
  * the retrieved objects are compared with their control points, properties, and geometry
  * information to the original PlanarFigure objects.
  */
 int mitkPlanarFigureIOTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("PlanarFigureIO");
 
   // Create a number of PlanarFigure objects
   PlanarFigureIOTestClass::PlanarFigureList originalPlanarFigures =
       PlanarFigureIOTestClass::CreatePlanarFigures();
 
   // Create a number of "deep-copied" planar figures to test the DeepCopy function (deprecated)
   PlanarFigureIOTestClass::PlanarFigureList copiedPlanarFigures =
       PlanarFigureIOTestClass::CreateDeepCopiedPlanarFigures(originalPlanarFigures);
 
   PlanarFigureIOTestClass::VerifyPlanarFigures(originalPlanarFigures, copiedPlanarFigures );
 
   // Create a number of cloned planar figures to test the Clone function
   PlanarFigureIOTestClass::PlanarFigureList clonedPlanarFigures =
       PlanarFigureIOTestClass::CreateClonedPlanarFigures(originalPlanarFigures);
 
   PlanarFigureIOTestClass::VerifyPlanarFigures(originalPlanarFigures, clonedPlanarFigures );
 
   // Write PlanarFigure objects into temp file
   // tmpname
   static unsigned long count = 0;
   unsigned long n = count++;
   std::ostringstream name;
   for (int i = 0; i < 6; ++i)
   {
     name << char('a' + (n % 26));
     n /= 26;
   }
   std::string myname;
   myname.append(name.str());
 
   std::string fileName = itksys::SystemTools::GetCurrentWorkingDirectory() + myname + ".pf";
 
   PlanarFigureIOTestClass::SerializePlanarFigures( originalPlanarFigures, fileName );
 
   // Write PlanarFigure objects to memory buffers
   PlanarFigureIOTestClass::PlanarFigureToMemoryWriterList writersWithMemoryBuffers =
       PlanarFigureIOTestClass::SerializePlanarFiguresToMemoryBuffers( originalPlanarFigures );
 
   // Read PlanarFigure objects from temp file
   PlanarFigureIOTestClass::PlanarFigureList retrievedPlanarFigures =
       PlanarFigureIOTestClass::DeserializePlanarFigures( fileName );
 
   // Read PlanarFigure objects from memory buffers
   PlanarFigureIOTestClass::PlanarFigureList retrievedPlanarFiguresFromMemory =
       PlanarFigureIOTestClass::DeserializePlanarFiguresFromMemoryBuffers( writersWithMemoryBuffers );
 
   PlanarFigureIOTestClass::PlanarFigureToMemoryWriterList::iterator it = writersWithMemoryBuffers.begin();
   while(it != writersWithMemoryBuffers.end())
   {
     (*it)->ReleaseMemory();
     ++it;
   }
 
   // Test if original and retrieved PlanarFigure objects are the same
   PlanarFigureIOTestClass::VerifyPlanarFigures( originalPlanarFigures, retrievedPlanarFigures );
 
   // Test if original and memory retrieved PlanarFigure objects are the same
   PlanarFigureIOTestClass::VerifyPlanarFigures( originalPlanarFigures, retrievedPlanarFiguresFromMemory );
 
   //empty the originalPlanarFigures
   originalPlanarFigures.empty();
 
   // Test if deep-copied and retrieved PlanarFigure objects are the same
   PlanarFigureIOTestClass::VerifyPlanarFigures( copiedPlanarFigures, retrievedPlanarFigures );
 
 
 
 
 
   MITK_TEST_END()
     }
diff --git a/Modules/PlanarFigure/Testing/mitkPlanarPolygonTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarPolygonTest.cpp
index e0c41dd6fd..0ea327c963 100644
--- a/Modules/PlanarFigure/Testing/mitkPlanarPolygonTest.cpp
+++ b/Modules/PlanarFigure/Testing/mitkPlanarPolygonTest.cpp
@@ -1,151 +1,151 @@
 /*===================================================================
 
 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 "mitkPlanarPolygon.h"
 #include "mitkPlaneGeometry.h"
 
 
 class mitkPlanarPolygonTestClass
 {
 
 public:
 
 
 static void TestPlanarPolygonPlacement( mitk::PlanarPolygon::Pointer planarPolygon )
 {
   // Test for correct minimum number of control points in cross-mode
   MITK_TEST_CONDITION( planarPolygon->GetMinimumNumberOfControlPoints() == 3, "Minimum number of control points" );
 
   // Test for correct maximum number of control points in cross-mode
   MITK_TEST_CONDITION( planarPolygon->GetMaximumNumberOfControlPoints() == 1000, "Maximum number of control points" );
 
   // Initial placement of PlanarPolygon
   mitk::Point2D p0;
   p0[0] = 00.0; p0[1] = 0.0;
   planarPolygon->PlaceFigure( p0 );
 
   // Add second control point
   mitk::Point2D p1;
   p1[0] = 50.0; p1[1] = 00.0;
   planarPolygon->SetControlPoint(1, p1 );
 
   // Add third control point
   mitk::Point2D p2;
   p2[0] = 50.0; p2[1] = 50.0;
   planarPolygon->AddControlPoint( p2 );
 
   // Add fourth control point
   mitk::Point2D p3;
   p3[0] = 0.0; p3[1] = 50.0;
   planarPolygon->AddControlPoint( p3 );
 
   // Test for number of control points
   MITK_TEST_CONDITION( planarPolygon->GetNumberOfControlPoints() == 4, "Number of control points after placement" );
 
   // Test if PlanarFigure is closed
   MITK_TEST_CONDITION( planarPolygon->IsClosed(), "planar polygon should not be closed, yet, right?" );
 
   planarPolygon->SetClosed(true);
 
   MITK_TEST_CONDITION( planarPolygon->IsClosed(), "planar polygon should be closed after function call, right?" );
 
   // Test for number of polylines
   const mitk::PlanarFigure::PolyLineType polyLine0 = planarPolygon->GetPolyLine( 0 );
   mitk::PlanarFigure::PolyLineType::const_iterator iter = polyLine0.begin();
   MITK_TEST_CONDITION( planarPolygon->GetPolyLinesSize() == 1, "Number of polylines after placement" );
 
   // Get polylines and check if the generated coordinates are OK
   const mitk::Point2D& pp0 = iter->Point;
   ++iter;
   const mitk::Point2D& pp1 = iter->Point;
   MITK_TEST_CONDITION( ((pp0 == p0) && (pp1 == p1))
     || ((pp0 == p1) && (pp1 == p0)), "Correct polyline 1" );
 
 
   // Test for number of measurement features
   planarPolygon->EvaluateFeatures();
   MITK_TEST_CONDITION( planarPolygon->GetNumberOfFeatures() == 2, "Number of measurement features" );
 
   // Test for correct feature evaluation
   double length0 = 4 * 50.0; // circumference
   MITK_TEST_CONDITION( fabs( planarPolygon->GetQuantity( 0 ) - length0) < mitk::eps, "Size of longest diameter" );
 
   double length1 = 50.0 * 50.0 ; // area
   MITK_TEST_CONDITION( fabs( planarPolygon->GetQuantity( 1 ) - length1) < mitk::eps, "Size of short axis diameter" );
 }
 
 static void TestPlanarPolygonEditing( mitk::PlanarPolygon::Pointer planarPolygon )
 {
   unsigned int initialNumberOfControlPoints = planarPolygon->GetNumberOfControlPoints();
 
   mitk::Point2D pnt;
   pnt[0] = 75.0; pnt[1] = 25.0;
   planarPolygon->AddControlPoint( pnt);
 
   MITK_TEST_CONDITION( planarPolygon->GetNumberOfControlPoints() == initialNumberOfControlPoints+1, "A new control-point shall be added" );
   MITK_TEST_CONDITION( planarPolygon->GetControlPoint( planarPolygon->GetNumberOfControlPoints()-1 ) == pnt, "Control-point shall be added at the end." );
 
 
   planarPolygon->RemoveControlPoint( 3 );
   MITK_TEST_CONDITION( planarPolygon->GetNumberOfControlPoints() == initialNumberOfControlPoints, "A control-point has been removed" );
   MITK_TEST_CONDITION( planarPolygon->GetControlPoint( 3 ) == pnt, "It shall be possible to remove any control-point." );
 
   planarPolygon->RemoveControlPoint( 0 );
   planarPolygon->RemoveControlPoint( 0 );
   planarPolygon->RemoveControlPoint( 0 );
   MITK_TEST_CONDITION( planarPolygon->GetNumberOfControlPoints() == 3, "Control-points cannot be removed if only three points remain." );
 
   mitk::Point2D pnt1;
   pnt1[0] = 33.0; pnt1[1] = 33.0;
   planarPolygon->AddControlPoint( pnt1, 0 );
   MITK_TEST_CONDITION( planarPolygon->GetNumberOfControlPoints() == 4, "A control-point has been added" );
   MITK_TEST_CONDITION( planarPolygon->GetControlPoint( 0 ) == pnt1, "It shall be possible to insert a control-point at any position." );
 
 }
 
 };
 /**
  * mitkplanarPolygonTest tests the methods and behavior of mitk::PlanarPolygon with sub-tests:
  *
  * 1. Instantiation and basic tests, including feature evaluation
  *
  */
 int mitkPlanarPolygonTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("planarPolygon")
 
   // create PlaneGeometry on which to place the planarPolygon
   mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane( 100.0, 100.0 );
 
   // **************************************************************************
   // 1. Instantiation and basic tests, including feature evaluation
   mitk::PlanarPolygon::Pointer planarPolygon = mitk::PlanarPolygon::New();
-  planarPolygon->SetGeometry2D( planeGeometry );
+  planarPolygon->SetPlaneGeometry( planeGeometry );
 
   // first test: did this work?
   MITK_TEST_CONDITION_REQUIRED( planarPolygon.IsNotNull(), "Testing instantiation" );
 
   // Test placement of planarPolygon by control points
   mitkPlanarPolygonTestClass::TestPlanarPolygonPlacement( planarPolygon );
 
   mitkPlanarPolygonTestClass::TestPlanarPolygonEditing( planarPolygon );
 
   // always end with this!
   MITK_TEST_END();
 }
diff --git a/Modules/PlanarFigure/Testing/mitkPlanarSubdivisionPolygonTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarSubdivisionPolygonTest.cpp
index 8b549a5b66..973796119c 100644
--- a/Modules/PlanarFigure/Testing/mitkPlanarSubdivisionPolygonTest.cpp
+++ b/Modules/PlanarFigure/Testing/mitkPlanarSubdivisionPolygonTest.cpp
@@ -1,195 +1,195 @@
 /*===================================================================
 
 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 "mitkPlanarSubdivisionPolygon.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 
 class mitkPlanarSubdivisionPolygonTestClass
 {
 
 public:
 
 
 static void TestPlanarSubdivisionPolygonPlacement( mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygon )
 {
   // Test for correct minimum number of control points in cross-mode
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetMinimumNumberOfControlPoints() == 3, "Minimum number of control points" );
 
   // Test for correct maximum number of control points in cross-mode
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetMaximumNumberOfControlPoints() == 1000, "Maximum number of control points" );
 
   // Test for correct rounds of subdivisionPoints
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetSubdivisionRounds() == 5, "Subdivision point generation depth" );
 
   // Test for correct tension parameter
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetTensionParameter() == 0.0625, "Tension parameter" );
 
   planarSubdivisionPolygon->SetProperty( "initiallyplaced", mitk::BoolProperty::New( true ) );
 
   // Initial placement of planarSubdivisionPolygon
   mitk::Point2D p0;
   p0[0] = 25.0; p0[1] = 25.0;
   planarSubdivisionPolygon->PlaceFigure( p0 );
 
   // Add second control point
   mitk::Point2D p1;
   p1[0] = 75.0; p1[1] = 25.0;
   planarSubdivisionPolygon->SetControlPoint(1, p1 );
 
   // Add third control point
   mitk::Point2D p2;
   p2[0] = 75.0; p2[1] = 75.0;
   planarSubdivisionPolygon->AddControlPoint( p2 );
 
   // Add fourth control point
   mitk::Point2D p3;
   p3[0] = 25.0; p3[1] = 75.0;
   planarSubdivisionPolygon->AddControlPoint( p3 );
 
   // Test for number of control points
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetNumberOfControlPoints() == 4, "Number of control points after placement" );
 
   // Test if PlanarFigure is closed
   MITK_TEST_CONDITION( planarSubdivisionPolygon->IsClosed(), "Test if property 'closed' is set by default" );
 
   // Test for number of polylines
   const mitk::PlanarFigure::PolyLineType polyLine0 = planarSubdivisionPolygon->GetPolyLine( 0 );
   mitk::PlanarFigure::PolyLineType::const_iterator iter = polyLine0.begin();
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetPolyLinesSize() == 1, "Number of polylines after placement" );
 
   // Test if subdivision point count is correct
   MITK_TEST_CONDITION( polyLine0.size() == 128, "correct number of subdivision points for this depth level" );
 
   // Test if control points are in correct order between subdivision points
   bool correctPoint = true;
   iter = polyLine0.begin();
 
   if( iter->Point != p0 ){ correctPoint = false; }
   advance(iter, 32);
   if( iter->Point != p1 ){ correctPoint = false; }
   advance(iter, 32);
   if( iter->Point != p2 ){ correctPoint = false; }
   advance(iter, 32);
   if( iter->Point != p3 ){ correctPoint = false; }
   MITK_TEST_CONDITION( correctPoint, "Test if control points are in correct order in polyline" );
 
 
   // Test if a picked point has the correct coordinates
   correctPoint = true;
 
   mitk::Point2D testPoint;
   testPoint[0] = 81.25;
   testPoint[1] = 48.243;
   iter = polyLine0.begin();
   advance(iter, 47);
 
   mitk::ScalarType testEps = 1E-5;
 
   if( (iter->Point[0] - testPoint[0]) + (iter->Point[1] - testPoint[1]) > testEps ){ correctPoint = false; }
 
   testPoint[0] = 39.624;
   testPoint[1] = 19.3268;
   iter = polyLine0.begin();
   advance(iter, 10);
   if( (iter->Point[0] - testPoint[0]) + (iter->Point[1] - testPoint[1]) > testEps ){ correctPoint = false; }
 
   testPoint[0] = 71.2887;
   testPoint[1] = 77.5248;
   iter = polyLine0.begin();
   advance(iter, 67);
   if( (iter->Point[0] - testPoint[0]) + (iter->Point[1] - testPoint[1]) > testEps ){ correctPoint = false; }
 
   MITK_TEST_CONDITION( correctPoint, "Test if subdivision points are calculated correctly" )
 
   // Test for number of measurement features
   /*
   Does not work yet
 
   planarSubdivisionPolygon->EvaluateFeatures();
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetNumberOfFeatures() == 2, "Number of measurement features" );
 
   // Test for correct feature evaluation
   double length0 = 4 * 50.0; // circumference
   MITK_TEST_CONDITION( fabs( planarSubdivisionPolygon->GetQuantity( 0 ) - length0) < mitk::eps, "Size of longest diameter" );
 
   double length1 = 50.0 * 50.0 ; // area
   MITK_TEST_CONDITION( fabs( planarSubdivisionPolygon->GetQuantity( 1 ) - length1) < mitk::eps, "Size of short axis diameter" );
   */
 }
 
 static void TestPlanarSubdivisionPolygonEditing( mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygon )
 {
   unsigned int initialNumberOfControlPoints = planarSubdivisionPolygon->GetNumberOfControlPoints();
 
   mitk::Point2D pnt;
   pnt[0] = 75.0; pnt[1] = 25.0;
   planarSubdivisionPolygon->AddControlPoint( pnt);
 
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetNumberOfControlPoints() == initialNumberOfControlPoints+1, "A new control-point shall be added" );
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetControlPoint( planarSubdivisionPolygon->GetNumberOfControlPoints()-1 ) == pnt, "Control-point shall be added at the end." );
 
 
   planarSubdivisionPolygon->RemoveControlPoint( 3 );
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetNumberOfControlPoints() == initialNumberOfControlPoints, "A control-point has been removed" );
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetControlPoint( 3 ) == pnt, "It shall be possible to remove any control-point." );
 
   planarSubdivisionPolygon->RemoveControlPoint( 0 );
   planarSubdivisionPolygon->RemoveControlPoint( 0 );
   planarSubdivisionPolygon->RemoveControlPoint( 0 );
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetNumberOfControlPoints() == 3, "Control-points cannot be removed if only three points remain." );
 
   mitk::Point2D pnt1;
   pnt1[0] = 33.0; pnt1[1] = 33.0;
   planarSubdivisionPolygon->AddControlPoint( pnt1, 0 );
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetNumberOfControlPoints() == 4, "A control-point has been added" );
   MITK_TEST_CONDITION( planarSubdivisionPolygon->GetControlPoint( 0 ) == pnt1, "It shall be possible to insert a control-point at any position." );
 
 }
 
 };
 /**
  * mitkplanarSubdivisionPolygonTest tests the methods and behavior of mitk::planarSubdivisionPolygon with sub-tests:
  *
  * 1. Instantiation and basic tests, including feature evaluation
  *
  */
 int mitkPlanarSubdivisionPolygonTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("planarSubdivisionPolygon")
 
   // create PlaneGeometry on which to place the planarSubdivisionPolygon
   mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane( 100.0, 100.0 );
 
   // **************************************************************************
   // 1. Instantiation and basic tests, including feature evaluation
   mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygon = mitk::PlanarSubdivisionPolygon::New();
-  planarSubdivisionPolygon->SetGeometry2D( planeGeometry );
+  planarSubdivisionPolygon->SetPlaneGeometry( planeGeometry );
 
   // first test: did this work?
   MITK_TEST_CONDITION_REQUIRED( planarSubdivisionPolygon.IsNotNull(), "Testing instantiation" );
 
   // Test placement of planarSubdivisionPolygon by control points
   mitkPlanarSubdivisionPolygonTestClass::TestPlanarSubdivisionPolygonPlacement( planarSubdivisionPolygon );
 
   mitkPlanarSubdivisionPolygonTestClass::TestPlanarSubdivisionPolygonEditing( planarSubdivisionPolygon );
 
   // always end with this!
   MITK_TEST_END();
 }
diff --git a/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp b/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp
index 518d6fae79..efc09f30e4 100644
--- a/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp
+++ b/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp
@@ -1,313 +1,313 @@
 /*===================================================================
 
 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 "mitkPlanarFigureSegmentationController.h"
 
 #include "mitkSurfaceToImageFilter.h"
 
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkPolygon.h>
 #include <vtkCellArray.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkImageData.h>
 #include "mitkImageWriter.h"
 #include "mitkSurfaceVtkWriter.h"
 #include "mitkImageToSurfaceFilter.h"
 
 #include "mitkImageAccessByItk.h"
 
 #include "mitkImageCast.h"
 
 
 mitk::PlanarFigureSegmentationController::PlanarFigureSegmentationController()
 : itk::Object()
 , m_ReduceFilter( NULL )
 , m_NormalsFilter( NULL )
 , m_DistanceImageCreator( NULL )
 , m_ReferenceImage( NULL )
 , m_SegmentationAsImage( NULL )
 {
   InitializeFilters();
 }
 
 mitk::PlanarFigureSegmentationController::~PlanarFigureSegmentationController()
 {
 }
 
 void mitk::PlanarFigureSegmentationController::SetReferenceImage( mitk::Image::Pointer referenceImage )
 {
   m_ReferenceImage = referenceImage;
 }
 
 void mitk::PlanarFigureSegmentationController::AddPlanarFigure( mitk::PlanarFigure::Pointer planarFigure )
 {
   if ( planarFigure.IsNull() )
     return;
 
   bool newFigure = true;
   std::size_t indexOfFigure = 0;
   for( std::size_t i=0; i<m_PlanarFigureList.size(); i++ )
   {
     if( m_PlanarFigureList.at(i) == planarFigure )
     {
       indexOfFigure = i;
       newFigure = false;
       break;
     }
   }
 
   mitk::Surface::Pointer figureAsSurface = NULL;
 
   if ( newFigure )
   {
     m_PlanarFigureList.push_back( planarFigure );
     figureAsSurface = this->CreateSurfaceFromPlanarFigure( planarFigure );
     m_SurfaceList.push_back( figureAsSurface );
     if (!m_PlanarFigureList.empty())
     {
       indexOfFigure = m_PlanarFigureList.size() -1 ;
     }
   }
   else
   {
     figureAsSurface = this->CreateSurfaceFromPlanarFigure( planarFigure );
     m_SurfaceList.at(indexOfFigure) = figureAsSurface;
   }
 
   if ( m_ReduceFilter.IsNull() )
   {
     InitializeFilters();
   }
 
   m_ReduceFilter->SetInput( indexOfFigure, figureAsSurface );
 
   m_NormalsFilter->SetInput( indexOfFigure, m_ReduceFilter->GetOutput( indexOfFigure ) );
   m_DistanceImageCreator->SetInput( indexOfFigure, m_NormalsFilter->GetOutput( indexOfFigure ) );
 }
 
 void mitk::PlanarFigureSegmentationController::RemovePlanarFigure( mitk::PlanarFigure::Pointer planarFigure )
 {
   if ( planarFigure.IsNull() )
     return;
 
   bool figureFound = false;
   std::size_t indexOfFigure = 0;
   for( std::size_t i=0; i<m_PlanarFigureList.size(); i++ )
   {
     if( m_PlanarFigureList.at(i) == planarFigure )
     {
       indexOfFigure = i;
       figureFound = true;
       break;
     }
   }
 
   if ( !figureFound )
     return;
 
   // TODO: fix this! The following code had to be removed as the method
   // RemoveInputs() has been removed in ITK 4
   // The remaining code works correctly but is slower
   if ( false && indexOfFigure == m_PlanarFigureList.size()-1 )
   {
     // Ff the removed figure was the last one in the list, we can simply
     // remove the last input from each filter.
 //     m_DistanceImageCreator->RemoveInputs( m_NormalsFilter->GetOutput( indexOfFigure ) );
 //     m_NormalsFilter->RemoveInput( m_ReduceFilter->GetOutput( indexOfFigure ) );
 //     m_ReduceFilter->RemoveInput( const_cast<mitk::Surface*>(m_ReduceFilter->GetInput(indexOfFigure)) );
   }
   else
   {
     // this is not very nice! If the figure that has been removed is NOT the last
     // one in the list we have to create new filters and add all remaining
     // inputs again.
     //
     // Has to be done as the filters do not work when removing an input
     // other than the last one.
 
     // create new filters
     InitializeFilters();
 
     // and add all existing surfaces
     SurfaceListType::iterator surfaceIter = m_SurfaceList.begin();
     for ( surfaceIter = m_SurfaceList.begin(); surfaceIter!=m_SurfaceList.end(); surfaceIter++ )
     {
       m_ReduceFilter->SetInput( indexOfFigure, (*surfaceIter) );
       m_NormalsFilter->SetInput( indexOfFigure, m_ReduceFilter->GetOutput( indexOfFigure ) );
       m_DistanceImageCreator->SetInput( indexOfFigure, m_NormalsFilter->GetOutput( indexOfFigure ) );
     }
   }
 
   PlanarFigureListType::iterator whereIter = m_PlanarFigureList.begin();
   whereIter += indexOfFigure;
   m_PlanarFigureList.erase( whereIter );
 
   SurfaceListType::iterator surfaceIter = m_SurfaceList.begin();
   surfaceIter += indexOfFigure;
   m_SurfaceList.erase( surfaceIter );
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::PlanarFigureSegmentationController::GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result)
 {
   result = input;
 }
 
 mitk::Image::Pointer mitk::PlanarFigureSegmentationController::GetInterpolationResult()
 {
   m_SegmentationAsImage = NULL;
 
   if ( m_PlanarFigureList.size() == 0 )
   {
     m_SegmentationAsImage = mitk::Image::New();
     m_SegmentationAsImage->Initialize(mitk::MakeScalarPixelType<unsigned char>() , *m_ReferenceImage->GetTimeGeometry());
 
     return m_SegmentationAsImage;
   }
 
   itk::ImageBase<3>::Pointer itkImage;
   AccessFixedDimensionByItk_1( m_ReferenceImage.GetPointer(), GetImageBase, 3, itkImage );
   m_DistanceImageCreator->SetReferenceImage( itkImage.GetPointer() );
 
   m_ReduceFilter->Update();
   m_NormalsFilter->Update();
   m_DistanceImageCreator->Update();
 
   mitk::Image::Pointer distanceImage = m_DistanceImageCreator->GetOutput();
 
   // Cleanup the pipeline
   distanceImage->DisconnectPipeline();
   m_DistanceImageCreator = NULL;
   m_NormalsFilter = NULL;
   m_ReduceFilter = NULL;
   itkImage = NULL;
 
   // If this bool flag is true, the distanceImage will be written to the
   // filesystem as nrrd-image and as surface-representation.
   bool debugOutput(false);
   if ( debugOutput )
   {
     mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
     imageWriter->SetInput( distanceImage );
     imageWriter->SetExtension( ".nrrd" );
     imageWriter->SetFileName( "v:/DistanceImage" );
     imageWriter->Update();
   }
 
   mitk::ImageToSurfaceFilter::Pointer imageToSurfaceFilter = mitk::ImageToSurfaceFilter::New();
   imageToSurfaceFilter->SetInput( distanceImage );
   imageToSurfaceFilter->SetThreshold( 0 );
   imageToSurfaceFilter->Update();
 
   mitk::Surface::Pointer segmentationAsSurface = imageToSurfaceFilter->GetOutput();
 
   // Cleanup the pipeline
   segmentationAsSurface->DisconnectPipeline();
   imageToSurfaceFilter = NULL;
 
   if ( debugOutput )
   {
     mitk::SurfaceVtkWriter<vtkPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkPolyDataWriter>::New();
     surfaceWriter->SetInput( segmentationAsSurface );
     surfaceWriter->SetExtension( ".vtk" );
     surfaceWriter->SetFileName( "v:/DistanceImageAsSurface.vtk" );
     surfaceWriter->Update();
   }
 
 
   mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
   surfaceToImageFilter->SetInput( segmentationAsSurface );
   surfaceToImageFilter->SetImage( m_ReferenceImage );
   surfaceToImageFilter->SetMakeOutputBinary(true);
   surfaceToImageFilter->Update();
 
   m_SegmentationAsImage = surfaceToImageFilter->GetOutput();
 
   // Cleanup the pipeline
   m_SegmentationAsImage->DisconnectPipeline();
 
   return m_SegmentationAsImage;
 }
 
 
 mitk::Surface::Pointer mitk::PlanarFigureSegmentationController::CreateSurfaceFromPlanarFigure( mitk::PlanarFigure::Pointer figure )
 {
   if ( figure.IsNull() )
   {
     MITK_ERROR << "Given PlanarFigure is NULL. Please provide valid PlanarFigure.";
     return NULL;
   }
 
   mitk::Surface::Pointer newSurface = mitk::Surface::New();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New();
   vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
 
-  const mitk::PlaneGeometry* figureGeometry = figure->GetGeometry2D();
+  const mitk::PlaneGeometry* figureGeometry = figure->GetPlaneGeometry();
 
   // Get the polyline
   mitk::PlanarFigure::PolyLineType planarPolyLine = figure->GetPolyLine(0);
   mitk::PlanarFigure::PolyLineType::iterator iter;
 
   // iterate over the polyline, ...
   int pointCounter = 0;
   for( iter = planarPolyLine.begin(); iter != planarPolyLine.end(); iter++ )
   {
     // ... determine the world-coordinates
     mitk::Point2D polyLinePoint = iter->Point;
     mitk::Point3D pointInWorldCoordiantes;
     figureGeometry->Map( polyLinePoint, pointInWorldCoordiantes );
 
     // and add them as new points to the vtkPoints
     points->InsertNextPoint( pointInWorldCoordiantes[0], pointInWorldCoordiantes[1], pointInWorldCoordiantes[2] );
     ++pointCounter;
   }
 
   // create a polygon with the points of the polyline
   polygon->GetPointIds()->SetNumberOfIds( pointCounter );
   for(int i = 0; i < pointCounter; i++)
   {
     polygon->GetPointIds()->SetId(i,i);
   }
 
   // initialize the vtkCellArray and vtkPolyData
   cells->InsertNextCell(polygon);
   polyData->SetPoints(points);
   polyData->SetPolys( cells );
 
   // set the polydata to the surface
   newSurface->SetVtkPolyData( polyData );
 
   return newSurface;
 }
 
 mitk::PlanarFigureSegmentationController::PlanarFigureListType mitk::PlanarFigureSegmentationController::GetAllPlanarFigures()
 {
   return m_PlanarFigureList;
 }
 
 void mitk::PlanarFigureSegmentationController::InitializeFilters()
 {
   m_ReduceFilter = mitk::ReduceContourSetFilter::New();
   m_ReduceFilter->SetReductionType(ReduceContourSetFilter::NTH_POINT);
   m_ReduceFilter->SetStepSize( 10 );
   m_NormalsFilter = mitk::ComputeContourSetNormalsFilter::New();
   m_DistanceImageCreator = mitk::CreateDistanceImageFromSurfaceFilter::New();
 }
diff --git a/Modules/QtWidgets/QmitkRenderWindowMenu.cpp b/Modules/QtWidgets/QmitkRenderWindowMenu.cpp
index 39d917aa37..ceb92c124b 100644
--- a/Modules/QtWidgets/QmitkRenderWindowMenu.cpp
+++ b/Modules/QtWidgets/QmitkRenderWindowMenu.cpp
@@ -1,1026 +1,1026 @@
 /*===================================================================
 
 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 "QmitkRenderWindowMenu.h"
 
 #include "mitkResliceMethodProperty.h"
 #include "mitkProperties.h"
 
 #include <QHBoxLayout>
 #include <QSpacerItem>
 #include <QSize>
 #include <QPainter>
 
 #include<QGroupBox>
 #include<QRadioButton>
 #include<QAction>
 #include<QLine>
 #include<QLabel>
 #include<QWidgetAction>
 
 #include <QTimer>
 
 #include "QmitkStdMultiWidget.h"
 
 //#include"iconClose.xpm"
 #include"iconFullScreen.xpm"
 #include"iconCrosshairMode.xpm"
 //#include"iconHoriSplit.xpm"
 #include"iconSettings.xpm"
 //#include"iconVertiSplit.xpm"
 #include"iconLeaveFullScreen.xpm"
 
 #include <math.h>
 
 #ifdef QMITK_USE_EXTERNAL_RENDERWINDOW_MENU
 QmitkRenderWindowMenu::QmitkRenderWindowMenu(QWidget *parent, Qt::WindowFlags f, mitk::BaseRenderer *b, QmitkStdMultiWidget* mw )
 :QWidget(parent, Qt::Tool | Qt::FramelessWindowHint ),
 
 #else
 QmitkRenderWindowMenu::QmitkRenderWindowMenu(QWidget *parent, Qt::WindowFlags f, mitk::BaseRenderer *b, QmitkStdMultiWidget* mw )
 :QWidget(parent,f),
 #endif
 
 m_Settings(NULL),
 m_CrosshairMenu(NULL),
 m_Layout(0),
 m_LayoutDesign(0),
 m_OldLayoutDesign(0),
 m_FullScreenMode(false),
 m_Entered(false),
 m_Hidden(true),
 m_Renderer(b),
 m_MultiWidget(mw)
 {
 
   MITK_DEBUG << "creating renderwindow menu on baserenderer " << b;
 
   //Create Menu Widget
   this->CreateMenuWidget();
   this->setMinimumWidth(61); //DIRTY.. If you add or remove a button, you need to change the size.
   this->setMaximumWidth(61);
   this->setAutoFillBackground( true );
 
   //Else part fixes the render window menu issue on Linux bug but caused bugs on Mac OS and Windows
   //for Mac OS see bug 3192
   //for Windows see bug 12130
   //... so Mac OS and Windows must be treated differently:
 #if defined(Q_OS_MAC) || defined(_WIN32)
   this->show();
   this->setWindowOpacity(0.0f);
 #else
   this->setVisible(false);
 #endif
 
   //this->setAttribute( Qt::WA_NoSystemBackground  );
   //this->setBackgroundRole( QPalette::Dark );
   //this->update();
 
   //SetOpacity  --  its just posible if the widget is a window.
   //Windows indicates that the widget is a window, usually with a window system frame and a title bar,
   //irrespective of whether the widget has a parent or not.
   /*
   this->setWindowFlags( Qt::Window | Qt::FramelessWindowHint);
   */
   //this->setAttribute(Qt::WA_TranslucentBackground);
   //this->setWindowOpacity(0.75);
 
   currentCrosshairRotationMode = 0;
 
   // for autorotating
   m_AutoRotationTimer.setInterval( 75 );
   connect( &m_AutoRotationTimer, SIGNAL(timeout()), this, SLOT(AutoRotateNextStep()) );
 }
 
 QmitkRenderWindowMenu::~QmitkRenderWindowMenu()
 {
   if( m_AutoRotationTimer.isActive() )
     m_AutoRotationTimer.stop();
 }
 
 
 
 void QmitkRenderWindowMenu::CreateMenuWidget()
 {
   QHBoxLayout* layout = new QHBoxLayout(this);
   layout->setAlignment( Qt::AlignRight );
   layout->setContentsMargins(1,1,1,1);
 
   QSize size( 13, 13 );
 
   m_CrosshairMenu = new QMenu(this);
   connect( m_CrosshairMenu, SIGNAL( aboutToShow() ), this, SLOT(OnCrossHairMenuAboutToShow()) );
 
   // button for changing rotation mode
   m_CrosshairModeButton = new QPushButton(this);
   m_CrosshairModeButton->setMaximumSize(15, 15);
   m_CrosshairModeButton->setIconSize(size);
   m_CrosshairModeButton->setFlat( true );
   m_CrosshairModeButton->setMenu( m_CrosshairMenu );
   m_CrosshairModeButton->setIcon( QIcon( iconCrosshairMode_xpm ) );
   layout->addWidget( m_CrosshairModeButton );
 
   //fullScreenButton
   m_FullScreenButton = new QPushButton(this);
   m_FullScreenButton->setMaximumSize(15, 15);
   m_FullScreenButton->setIconSize(size);
   m_FullScreenButton->setFlat( true );
   m_FullScreenButton->setIcon( QIcon( iconFullScreen_xpm ));
   layout->addWidget( m_FullScreenButton );
 
   //settingsButton
   m_SettingsButton = new QPushButton(this);
   m_SettingsButton->setMaximumSize(15, 15);
   m_SettingsButton->setIconSize(size);
   m_SettingsButton->setFlat( true );
   m_SettingsButton->setIcon( QIcon( iconSettings_xpm ));
   layout->addWidget( m_SettingsButton );
 
   //Create Connections -- coming soon?
   connect( m_FullScreenButton, SIGNAL( clicked(bool) ), this, SLOT(OnFullScreenButton(bool)) );
   connect( m_SettingsButton, SIGNAL( clicked(bool) ), this, SLOT(OnSettingsButton(bool)) );
 }
 
 void QmitkRenderWindowMenu::CreateSettingsWidget()
 {
   m_Settings = new QMenu(this);
 
   m_DefaultLayoutAction = new QAction( "standard layout", m_Settings );
   m_DefaultLayoutAction->setDisabled( true );
 
   m_2DImagesUpLayoutAction = new QAction( "2D images top, 3D bottom", m_Settings );
   m_2DImagesUpLayoutAction->setDisabled( false );
 
   m_2DImagesLeftLayoutAction = new QAction( "2D images left, 3D right", m_Settings );
   m_2DImagesLeftLayoutAction->setDisabled( false );
 
   m_Big3DLayoutAction = new QAction( "Big 3D", m_Settings );
   m_Big3DLayoutAction->setDisabled( false );
 
   m_Widget1LayoutAction = new QAction( "Axial plane", m_Settings );
   m_Widget1LayoutAction->setDisabled( false );
 
   m_Widget2LayoutAction = new QAction( "Sagittal plane", m_Settings );
   m_Widget2LayoutAction->setDisabled( false );
 
   m_Widget3LayoutAction = new QAction( "Coronal plane", m_Settings );
   m_Widget3LayoutAction->setDisabled( false );
 
   m_RowWidget3And4LayoutAction = new QAction( "Coronal top, 3D bottom", m_Settings );
   m_RowWidget3And4LayoutAction->setDisabled( false );
 
   m_ColumnWidget3And4LayoutAction = new QAction( "Coronal left, 3D right", m_Settings );
   m_ColumnWidget3And4LayoutAction->setDisabled( false );
 
   m_SmallUpperWidget2Big3and4LayoutAction = new QAction( "Sagittal top, Coronal n 3D bottom", m_Settings );
   m_SmallUpperWidget2Big3and4LayoutAction->setDisabled( false );
 
   m_2x2Dand3DWidgetLayoutAction = new QAction( "Axial n Sagittal left, 3D right", m_Settings );
   m_2x2Dand3DWidgetLayoutAction->setDisabled( false );
 
   m_Left2Dand3DRight2DLayoutAction = new QAction( "Axial n 3D left, Sagittal right", m_Settings );
   m_Left2Dand3DRight2DLayoutAction->setDisabled( false );
 
   m_Settings->addAction(m_DefaultLayoutAction);
   m_Settings->addAction(m_2DImagesUpLayoutAction);
   m_Settings->addAction(m_2DImagesLeftLayoutAction);
   m_Settings->addAction(m_Big3DLayoutAction);
   m_Settings->addAction(m_Widget1LayoutAction);
   m_Settings->addAction(m_Widget2LayoutAction);
   m_Settings->addAction(m_Widget3LayoutAction);
   m_Settings->addAction(m_RowWidget3And4LayoutAction);
   m_Settings->addAction(m_ColumnWidget3And4LayoutAction);
   m_Settings->addAction(m_SmallUpperWidget2Big3and4LayoutAction);
   m_Settings->addAction(m_2x2Dand3DWidgetLayoutAction);
   m_Settings->addAction(m_Left2Dand3DRight2DLayoutAction);
 
   m_Settings->setVisible( false );
 
   connect( m_DefaultLayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToDefault(bool)) );
   connect( m_2DImagesUpLayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutTo2DImagesUp(bool)) );
   connect( m_2DImagesLeftLayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutTo2DImagesLeft(bool)) );
   connect( m_Big3DLayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToBig3D(bool)) );
   connect( m_Widget1LayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToWidget1(bool)) );
   connect( m_Widget2LayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToWidget2(bool)) );
   connect( m_Widget3LayoutAction  , SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToWidget3(bool)) );
   connect( m_RowWidget3And4LayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToRowWidget3And4(bool)) );
   connect( m_ColumnWidget3And4LayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToColumnWidget3And4(bool)) );
   connect( m_SmallUpperWidget2Big3and4LayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToSmallUpperWidget2Big3and4(bool)) );
   connect( m_2x2Dand3DWidgetLayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutTo2x2Dand3DWidget(bool)) );
   connect( m_Left2Dand3DRight2DLayoutAction, SIGNAL( triggered(bool) ), this, SLOT(OnChangeLayoutToLeft2Dand3DRight2D(bool)) );
 
 }
 
 void QmitkRenderWindowMenu::paintEvent( QPaintEvent*  /*e*/ )
 {
   QPainter painter(this);
   QColor semiTransparentColor = Qt::black;
   semiTransparentColor.setAlpha(255);
   painter.fillRect(rect(), semiTransparentColor);
 }
 
 void QmitkRenderWindowMenu::SetLayoutIndex( unsigned int layoutIndex )
 {
   m_Layout = layoutIndex;
 }
 
 void QmitkRenderWindowMenu::HideMenu( )
 {
   MITK_DEBUG << "menu hideEvent";
 
   m_Hidden = true;
 
   if( ! m_Entered )
   {
      //Else part fixes the render window menu issue on Linux bug but caused bugs on Mac OS and Windows
      //for Mac OS see bug 3192
      //for Windows see bug 12130
      //... so Mac OS and Windows must be treated differently:
 #if defined(Q_OS_MAC) || defined(_WIN32)
     this->setWindowOpacity(0.0f);
 #else
     this->setVisible(false);
 #endif
   }
 }
 
 void QmitkRenderWindowMenu::ShowMenu( )
 {
   MITK_DEBUG << "menu showMenu";
 
   m_Hidden = false;
   //Else part fixes the render window menu issue on Linux bug but caused bugs on Mac OS and Windows
   //for Mac OS see bug 3192
   //for Windows see bug 12130
   //... so Mac OS and Windows must be treated differently:
 #if defined(Q_OS_MAC) || defined(_WIN32)
   this->setWindowOpacity(1.0f);
 #else
   this->setVisible(true);
 #endif
 }
 
 
 void QmitkRenderWindowMenu::enterEvent( QEvent * /*e*/ )
 {
   MITK_DEBUG << "menu enterEvent";
 
   m_Entered=true;
 
   m_Hidden=false;
 }
 
 void QmitkRenderWindowMenu::DeferredHideMenu( )
 {
   MITK_DEBUG << "menu deferredhidemenu";
   if(m_Hidden)
   {
   //Else part fixes the render window menu issue on Linux bug but caused bugs on Mac OS and Windows
   //for Mac OS see bug 3192
   //for Windows see bug 12130
   //... so Mac OS and Windows must be treated differently:
 #if defined(Q_OS_MAC) || defined(_WIN32)
   this->setWindowOpacity(0.0f);
 #else
   this->setVisible(false);
 #endif
   }
 
 //    setVisible(false);
 //    setWindowOpacity(0.0f);
   ///hide();
 }
 
 void QmitkRenderWindowMenu::leaveEvent( QEvent * /*e*/ )
 {
   MITK_DEBUG << "menu leaveEvent";
 
   smoothHide();
 
 }
 
 /* This method is responsible for non fluttering of
  the renderWindowMenu when mouse cursor moves along the renderWindowMenu*/
 void QmitkRenderWindowMenu::smoothHide()
 {
 
   MITK_DEBUG<< "menu leaveEvent";
 
   m_Entered=false;
 
   m_Hidden = true;
 
   QTimer::singleShot(10,this,SLOT( DeferredHideMenu( ) ) );
 
 
 }
 
 
 void QmitkRenderWindowMenu::ChangeFullScreenMode( bool state )
 {
   this->OnFullScreenButton( state );
 }
 /// \brief
 void QmitkRenderWindowMenu::OnFullScreenButton( bool  /*checked*/ )
 {
   if( !m_FullScreenMode )
   {
     m_FullScreenMode = true;
     m_OldLayoutDesign = m_LayoutDesign;
 
     switch( m_Layout )
     {
     case AXIAL:
       {
         emit SignalChangeLayoutDesign( LAYOUT_AXIAL );
         break;
       }
 
     case SAGITTAL:
       {
         emit SignalChangeLayoutDesign( LAYOUT_SAGITTAL );
         break;
       }
     case CORONAL:
       {
         emit SignalChangeLayoutDesign( LAYOUT_CORONAL );
         break;
       }
     case THREE_D:
       {
         emit SignalChangeLayoutDesign( LAYOUT_BIG3D );
         break;
       }
     }
 
     //Move Widget and show again
     this->MoveWidgetToCorrectPos(1.0f);
 
     //change icon
     this->ChangeFullScreenIcon();
 
   }
   else
   {
     m_FullScreenMode = false;
     emit SignalChangeLayoutDesign( m_OldLayoutDesign );
 
     //Move Widget and show again
     this->MoveWidgetToCorrectPos(1.0f);
 
     //change icon
     this->ChangeFullScreenIcon();
   }
 
   DeferredShowMenu( );
 
 }
 
 
 /// \brief
 void QmitkRenderWindowMenu::OnSettingsButton( bool  /*checked*/ )
 {
   if( m_Settings == NULL )
     this->CreateSettingsWidget();
 
   QPoint point = this->mapToGlobal( m_SettingsButton->geometry().topLeft() );
   m_Settings->setVisible( true );
   m_Settings->exec( point );
 }
 
 void QmitkRenderWindowMenu::OnChangeLayoutTo2DImagesUp(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_2DIMAGEUP;
   emit SignalChangeLayoutDesign( LAYOUT_2DIMAGEUP );
 
   DeferredShowMenu( );
 
 }
 void QmitkRenderWindowMenu::OnChangeLayoutTo2DImagesLeft(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_2DIMAGELEFT;
   emit SignalChangeLayoutDesign( LAYOUT_2DIMAGELEFT );
 
   DeferredShowMenu( );
 }
 void QmitkRenderWindowMenu::OnChangeLayoutToDefault(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_DEFAULT;
   emit SignalChangeLayoutDesign( LAYOUT_DEFAULT );
 
   DeferredShowMenu( );
 
 }
 
 void QmitkRenderWindowMenu::DeferredShowMenu()
 {
 
   MITK_DEBUG << "deferred show menu";
 
   //Else part fixes the render window menu issue on Linux bug but caused bugs on Mac OS and Windows
   //for Mac OS see bug 3192
   //for Windows see bug 12130
   //... so Mac OS and Windows must be treated differently:
 #if defined(Q_OS_MAC) || defined(_WIN32)
   this->setWindowOpacity(1.0f);
 #else
   this->setVisible(true);
 #endif
 }
 
 void QmitkRenderWindowMenu::OnChangeLayoutToBig3D(bool)
 {
   MITK_DEBUG << "OnChangeLayoutToBig3D";
 
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_BIG3D;
   emit SignalChangeLayoutDesign( LAYOUT_BIG3D );
 
   DeferredShowMenu( );
 
 }
 
 void QmitkRenderWindowMenu::OnChangeLayoutToWidget1(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_AXIAL;
   emit SignalChangeLayoutDesign( LAYOUT_AXIAL );
 
   DeferredShowMenu( );
 }
 void QmitkRenderWindowMenu::OnChangeLayoutToWidget2(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_SAGITTAL;
   emit SignalChangeLayoutDesign( LAYOUT_SAGITTAL );
 
   DeferredShowMenu( );
 }
 void QmitkRenderWindowMenu::OnChangeLayoutToWidget3(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_CORONAL;
   emit SignalChangeLayoutDesign( LAYOUT_CORONAL );
 
   DeferredShowMenu( );
 }
 void QmitkRenderWindowMenu::OnChangeLayoutToRowWidget3And4(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_ROWWIDGET3AND4;
   emit SignalChangeLayoutDesign( LAYOUT_ROWWIDGET3AND4 );
 
   DeferredShowMenu( );
 }
 void QmitkRenderWindowMenu::OnChangeLayoutToColumnWidget3And4(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_COLUMNWIDGET3AND4;
   emit SignalChangeLayoutDesign( LAYOUT_COLUMNWIDGET3AND4 );
 
   DeferredShowMenu( );
 }
 
 void QmitkRenderWindowMenu::OnChangeLayoutToSmallUpperWidget2Big3and4(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_SMALLUPPERWIDGET2BIGAND4;
   emit SignalChangeLayoutDesign( LAYOUT_SMALLUPPERWIDGET2BIGAND4 );
 
   DeferredShowMenu( );
 }
 void QmitkRenderWindowMenu::OnChangeLayoutTo2x2Dand3DWidget(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_2X2DAND3DWIDGET;
   emit SignalChangeLayoutDesign( LAYOUT_2X2DAND3DWIDGET );
 
   DeferredShowMenu( );
 }
 void QmitkRenderWindowMenu::OnChangeLayoutToLeft2Dand3DRight2D(bool)
 {
   //set Full Screen Mode to false, if Layout Design was changed by the LayoutDesign_List
   m_FullScreenMode = false;
   this->ChangeFullScreenIcon();
 
   m_LayoutDesign = LAYOUT_LEFT2DAND3DRIGHT2D;
   emit SignalChangeLayoutDesign( LAYOUT_LEFT2DAND3DRIGHT2D );
 
   DeferredShowMenu( );
 }
 
 void QmitkRenderWindowMenu::UpdateLayoutDesignList( int layoutDesignIndex )
 {
   m_LayoutDesign = layoutDesignIndex;
 
   if( m_Settings == NULL )
     this->CreateSettingsWidget();
 
   switch( m_LayoutDesign )
   {
   case LAYOUT_DEFAULT:
     {
       m_DefaultLayoutAction->setEnabled(false);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
 
   case LAYOUT_2DIMAGEUP:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(false);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_2DIMAGELEFT:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(false);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_BIG3D:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(false);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_AXIAL:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(false);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_SAGITTAL:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(false);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_CORONAL:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(false);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_2X2DAND3DWIDGET:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(false);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_ROWWIDGET3AND4:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(false);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_COLUMNWIDGET3AND4:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(false);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_SMALLUPPERWIDGET2BIGAND4:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(false);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(true);
       break;
     }
   case LAYOUT_LEFT2DAND3DRIGHT2D:
     {
       m_DefaultLayoutAction->setEnabled(true);
       m_2DImagesUpLayoutAction->setEnabled(true);
       m_2DImagesLeftLayoutAction->setEnabled(true);
       m_Big3DLayoutAction->setEnabled(true);
       m_Widget1LayoutAction->setEnabled(true);
       m_Widget2LayoutAction->setEnabled(true);
       m_Widget3LayoutAction->setEnabled(true);
       m_RowWidget3And4LayoutAction->setEnabled(true);
       m_ColumnWidget3And4LayoutAction->setEnabled(true);
       m_SmallUpperWidget2Big3and4LayoutAction->setEnabled(true);
       m_2x2Dand3DWidgetLayoutAction->setEnabled(true);
       m_Left2Dand3DRight2DLayoutAction->setEnabled(false);
       break;
     }
   }
 }
 
 #ifdef QMITK_USE_EXTERNAL_RENDERWINDOW_MENU
 void QmitkRenderWindowMenu::MoveWidgetToCorrectPos(float opacity)
 #else
 void QmitkRenderWindowMenu::MoveWidgetToCorrectPos(float /*opacity*/)
 #endif
 {
 #ifdef QMITK_USE_EXTERNAL_RENDERWINDOW_MENU
   int X=floor( double(this->parentWidget()->width() - this->width() - 8.0) );
   int Y=7;
 
   QPoint pos = this->parentWidget()->mapToGlobal( QPoint(0,0) );
 
   this->move( X+pos.x(), Y+pos.y() );
 
   if(opacity<0) opacity=0;
   else if(opacity>1) opacity=1;
 
   this->setWindowOpacity(opacity);
 #else
   int moveX= floor( double(this->parentWidget()->width() - this->width() - 4.0) );
   this->move( moveX, 3 );
   this->show();
 #endif
 }
 
 void QmitkRenderWindowMenu::ChangeFullScreenIcon()
 {
 
  if( m_FullScreenMode )
  {
    const QIcon icon( iconLeaveFullScreen_xpm );
    m_FullScreenButton->setIcon(icon);
  }
   else
   {
     const QIcon icon( iconFullScreen_xpm );
     m_FullScreenButton->setIcon(icon);
  }
 }
 
 void QmitkRenderWindowMenu::OnCrosshairRotationModeSelected(QAction* action)
 {
   MITK_DEBUG << "selected crosshair mode " << action->data().toInt() ;
   emit ChangeCrosshairRotationMode( action->data().toInt() );
 }
 
 void QmitkRenderWindowMenu::SetCrossHairVisibility( bool state )
 {
   if(m_Renderer.IsNotNull())
   {
     mitk::DataNode *n;
     if(this->m_MultiWidget)
     {
       n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetVisibility(state);
       n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetVisibility(state);
       n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetVisibility(state);
       m_Renderer->GetRenderingManager()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkRenderWindowMenu::OnTSNumChanged(int num)
 {
   MITK_DEBUG << "Thickslices num: " << num << " on renderer " << m_Renderer.GetPointer();
 
   if(m_Renderer.IsNotNull())
   {
     if(num==0)
     {
-      m_Renderer->GetCurrentWorldGeometry2DNode()->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
-      m_Renderer->GetCurrentWorldGeometry2DNode()->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
+      m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
+      m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
     }
     else
     {
-      m_Renderer->GetCurrentWorldGeometry2DNode()->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 1 ) );
-      m_Renderer->GetCurrentWorldGeometry2DNode()->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
-      m_Renderer->GetCurrentWorldGeometry2DNode()->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( num > 1 ) );
+      m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 1 ) );
+      m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
+      m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( num > 1 ) );
     }
     m_TSLabel->setText(QString::number(num*2+1));
     m_Renderer->SendUpdateSlice();
     m_Renderer->GetRenderingManager()->RequestUpdateAll();
   }
 }
 
 
 
 void QmitkRenderWindowMenu::OnCrossHairMenuAboutToShow()
 {
   QMenu *crosshairModesMenu = m_CrosshairMenu;
 
   crosshairModesMenu->clear();
 
   QAction* resetViewAction = new QAction(crosshairModesMenu);
   resetViewAction->setText("Reset view");
   crosshairModesMenu->addAction( resetViewAction );
   connect( resetViewAction, SIGNAL(triggered()), this, SIGNAL(ResetView()));
 
   // Show hide crosshairs
   {
     bool currentState = true;
 
     if(m_Renderer.IsNotNull())
     {
       mitk::DataStorage *ds=m_Renderer->GetDataStorage();
       mitk::DataNode *n;
       if(ds)
       {
         n = this->m_MultiWidget->GetWidgetPlane1(); if(n) { bool v; if(n->GetVisibility(v,0)) currentState&=v; }
         n = this->m_MultiWidget->GetWidgetPlane2(); if(n) { bool v; if(n->GetVisibility(v,0)) currentState&=v; }
         n = this->m_MultiWidget->GetWidgetPlane3(); if(n) { bool v; if(n->GetVisibility(v,0)) currentState&=v; }
       }
     }
 
 
     QAction* showHideCrosshairVisibilityAction = new QAction(crosshairModesMenu);
     showHideCrosshairVisibilityAction->setText("Show crosshair");
     showHideCrosshairVisibilityAction->setCheckable(true);
     showHideCrosshairVisibilityAction->setChecked(currentState);
     crosshairModesMenu->addAction( showHideCrosshairVisibilityAction );
     connect( showHideCrosshairVisibilityAction, SIGNAL(toggled(bool)), this, SLOT(SetCrossHairVisibility(bool)));
   }
 
   // Rotation mode
   {
     QAction* rotationGroupSeparator = new QAction(crosshairModesMenu);
     rotationGroupSeparator->setSeparator(true);
     rotationGroupSeparator->setText("Rotation mode");
     crosshairModesMenu->addAction( rotationGroupSeparator );
 
     QActionGroup* rotationModeActionGroup = new QActionGroup(crosshairModesMenu);
     rotationModeActionGroup->setExclusive(true);
 
     QAction* noCrosshairRotation = new QAction(crosshairModesMenu);
     noCrosshairRotation->setActionGroup(rotationModeActionGroup);
     noCrosshairRotation->setText("No crosshair rotation");
     noCrosshairRotation->setCheckable(true);
     noCrosshairRotation->setChecked(currentCrosshairRotationMode==0);
     noCrosshairRotation->setData( 0 );
     crosshairModesMenu->addAction( noCrosshairRotation );
 
     QAction* singleCrosshairRotation = new QAction(crosshairModesMenu);
     singleCrosshairRotation->setActionGroup(rotationModeActionGroup);
     singleCrosshairRotation->setText("Crosshair rotation");
     singleCrosshairRotation->setCheckable(true);
     singleCrosshairRotation->setChecked(currentCrosshairRotationMode==1);
     singleCrosshairRotation->setData( 1  );
     crosshairModesMenu->addAction( singleCrosshairRotation );
 
     QAction* coupledCrosshairRotation = new QAction(crosshairModesMenu);
     coupledCrosshairRotation->setActionGroup(rotationModeActionGroup);
     coupledCrosshairRotation->setText("Coupled crosshair rotation");
     coupledCrosshairRotation->setCheckable(true);
     coupledCrosshairRotation->setChecked(currentCrosshairRotationMode==2);
     coupledCrosshairRotation->setData( 2 );
     crosshairModesMenu->addAction( coupledCrosshairRotation );
 
     QAction* swivelMode = new QAction(crosshairModesMenu);
     swivelMode->setActionGroup(rotationModeActionGroup);
     swivelMode->setText("Swivel mode");
     swivelMode->setCheckable(true);
     swivelMode->setChecked(currentCrosshairRotationMode==3);
     swivelMode->setData( 3 );
     crosshairModesMenu->addAction( swivelMode );
 
     connect( rotationModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnCrosshairRotationModeSelected(QAction*)) );
   }
 
   // auto rotation support
   if( m_Renderer.IsNotNull() && m_Renderer->GetMapperID() == mitk::BaseRenderer::Standard3D )
   {
     QAction* autoRotationGroupSeparator = new QAction(crosshairModesMenu);
     autoRotationGroupSeparator->setSeparator(true);
     crosshairModesMenu->addAction( autoRotationGroupSeparator );
 
     QAction* autoRotationAction = crosshairModesMenu->addAction( "Auto Rotation" );
     autoRotationAction->setCheckable(true);
     autoRotationAction->setChecked( m_AutoRotationTimer.isActive() );
     connect( autoRotationAction, SIGNAL(triggered()), this, SLOT(OnAutoRotationActionTriggered()) );
   }
 
   // Thickslices support
   if( m_Renderer.IsNotNull() && m_Renderer->GetMapperID() == mitk::BaseRenderer::Standard2D )
   {
     QAction* thickSlicesGroupSeparator = new QAction(crosshairModesMenu);
     thickSlicesGroupSeparator->setSeparator(true);
     thickSlicesGroupSeparator->setText("ThickSlices mode");
     crosshairModesMenu->addAction( thickSlicesGroupSeparator );
 
     QActionGroup* thickSlicesActionGroup = new QActionGroup(crosshairModesMenu);
     thickSlicesActionGroup->setExclusive(true);
 
     int currentMode = 0;
     {
-      mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(m_Renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices" ));
+      mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty( "reslice.thickslices" ));
       if( m.IsNotNull() )
         currentMode = m->GetValueAsId();
     }
 
     int currentNum = 1;
     {
-      mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(m_Renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices.num" ));
+      mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty( "reslice.thickslices.num" ));
       if( m.IsNotNull() )
       {
         currentNum = m->GetValue();
         if(currentNum < 1) currentNum = 1;
         if(currentNum > 10) currentNum = 10;
       }
     }
 
     if(currentMode==0)
       currentNum=0;
 
     QSlider *m_TSSlider = new QSlider(crosshairModesMenu);
     m_TSSlider->setMinimum(0);
     m_TSSlider->setMaximum(9);
     m_TSSlider->setValue(currentNum);
 
     m_TSSlider->setOrientation(Qt::Horizontal);
 
     connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
 
     QHBoxLayout* _TSLayout = new QHBoxLayout;
     _TSLayout->setContentsMargins(4,4,4,4);
     _TSLayout->addWidget(new QLabel("TS: "));
     _TSLayout->addWidget(m_TSSlider);
     _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),this));
 
     QWidget* _TSWidget = new QWidget;
     _TSWidget->setLayout(_TSLayout);
 
     QWidgetAction *m_TSSliderAction = new QWidgetAction(crosshairModesMenu);
     m_TSSliderAction->setDefaultWidget(_TSWidget);
     crosshairModesMenu->addAction(m_TSSliderAction);
   }
 }
 
 void QmitkRenderWindowMenu::NotifyNewWidgetPlanesMode( int mode )
 {
   currentCrosshairRotationMode = mode;
 }
 
 void QmitkRenderWindowMenu::OnAutoRotationActionTriggered()
 {
   if(m_AutoRotationTimer.isActive())
   {
     m_AutoRotationTimer.stop();
     m_Renderer->GetCameraRotationController()->GetSlice()->PingPongOff();
   }
   else
   {
     m_Renderer->GetCameraRotationController()->GetSlice()->PingPongOn();
     m_AutoRotationTimer.start();
   }
 }
 
 void QmitkRenderWindowMenu::AutoRotateNextStep()
 {
   if(m_Renderer->GetCameraRotationController())
     m_Renderer->GetCameraRotationController()->GetSlice()->Next();
 }
 
diff --git a/Modules/QtWidgets/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/QmitkStdMultiWidget.cpp
index 5c852d8980..c2c9b8b265 100644
--- a/Modules/QtWidgets/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/QmitkStdMultiWidget.cpp
@@ -1,2200 +1,2200 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QGridLayout>
 #include <qsplitter.h>
 #include <QMotifStyle>
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 #include "mitkProperties.h"
-#include "mitkGeometry2DDataMapper2D.h"
+#include "mitkPlaneGeometryDataMapper2D.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkPointSet.h"
 #include "mitkPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkLine.h"
 #include "mitkInteractionConst.h"
 #include "mitkDataStorage.h"
 #include "mitkOverlayManager.h"
 
 #include "mitkNodePredicateBase.h"
 #include "mitkNodePredicateDataType.h"
 
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkStatusBar.h"
 #include "mitkImage.h"
 
 #include "mitkVtkLayerController.h"
 
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget* parent, Qt::WindowFlags f, mitk::RenderingManager* renderingManager, mitk::BaseRenderer::RenderingMode::Type renderingMode)
 : QWidget(parent, f),
 mitkWidget1(NULL),
 mitkWidget2(NULL),
 mitkWidget3(NULL),
 mitkWidget4(NULL),
 levelWindowWidget(NULL),
 QmitkStdMultiWidgetLayout(NULL),
 m_Layout(LAYOUT_DEFAULT),
 m_PlaneMode(PLANE_MODE_SLICING),
 m_RenderingManager(renderingManager),
 m_GradientBackgroundFlag(true),
 m_TimeNavigationController(NULL),
 m_MainSplit(NULL),
 m_LayoutSplit(NULL),
 m_SubSplit1(NULL),
 m_SubSplit2(NULL),
 mitkWidget1Container(NULL),
 mitkWidget2Container(NULL),
 mitkWidget3Container(NULL),
 mitkWidget4Container(NULL),
 m_PendingCrosshairPositionEvent(false),
 m_CrosshairNavigationEnabled(false)
 {
   /******************************************************
    * Use the global RenderingManager if none was specified
    * ****************************************************/
   if (m_RenderingManager == NULL)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   /*******************************/
   //Create Widget manually
   /*******************************/
 
   //create Layouts
   QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
   QmitkStdMultiWidgetLayout->setContentsMargins(0,0,0,0);
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
 //  QmitkNavigationToolBar* toolBar = new QmitkNavigationToolBar();
 //  QmitkStdMultiWidgetLayout->addWidget( toolBar );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //creae Widget Container
   mitkWidget1Container = new QWidget(m_SubSplit1);
   mitkWidget2Container = new QWidget(m_SubSplit1);
   mitkWidget3Container = new QWidget(m_SubSplit2);
   mitkWidget4Container = new QWidget(m_SubSplit2);
 
   mitkWidget1Container->setContentsMargins(0,0,0,0);
   mitkWidget2Container->setContentsMargins(0,0,0,0);
   mitkWidget3Container->setContentsMargins(0,0,0,0);
   mitkWidget4Container->setContentsMargins(0,0,0,0);
 
   //create Widget Layout
   QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
   QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
   QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
   QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
 
   mitkWidgetLayout1->setMargin(0);
   mitkWidgetLayout2->setMargin(0);
   mitkWidgetLayout3->setMargin(0);
   mitkWidgetLayout4->setMargin(0);
 
   //set Layout to Widget Container
   mitkWidget1Container->setLayout(mitkWidgetLayout1);
   mitkWidget2Container->setLayout(mitkWidgetLayout2);
   mitkWidget3Container->setLayout(mitkWidgetLayout3);
   mitkWidget4Container->setLayout(mitkWidgetLayout4);
 
   //set SizePolicy
   mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 
   //insert Widget Container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //  m_RenderingManager->SetGlobalInteraction( mitk::GlobalInteraction::GetInstance() );
 
   //Create RenderWindows 1
   mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, "stdmulti.widget1", NULL, m_RenderingManager,renderingMode);
   mitkWidget1->setMaximumSize(2000,2000);
   mitkWidget1->SetLayoutIndex( AXIAL );
   mitkWidgetLayout1->addWidget(mitkWidget1);
 
   //Create RenderWindows 2
   mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, "stdmulti.widget2", NULL, m_RenderingManager,renderingMode);
   mitkWidget2->setMaximumSize(2000,2000);
   mitkWidget2->setEnabled( TRUE );
   mitkWidget2->SetLayoutIndex( SAGITTAL );
   mitkWidgetLayout2->addWidget(mitkWidget2);
 
   //Create RenderWindows 3
   mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, "stdmulti.widget3", NULL, m_RenderingManager,renderingMode);
   mitkWidget3->setMaximumSize(2000,2000);
   mitkWidget3->SetLayoutIndex( CORONAL );
   mitkWidgetLayout3->addWidget(mitkWidget3);
 
   //Create RenderWindows 4
   mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, "stdmulti.widget4", NULL, m_RenderingManager,renderingMode);
   mitkWidget4->setMaximumSize(2000,2000);
   mitkWidget4->SetLayoutIndex( THREE_D );
   mitkWidgetLayout4->addWidget(mitkWidget4);
 
   //create SignalSlot Connection
   connect( mitkWidget1, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget1, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget1, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget2, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget2, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget2, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget3, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget3, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget3, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget4, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget4, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget4, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   //Create Level Window Widget
   levelWindowWidget = new QmitkLevelWindowWidget( m_MainSplit ); //this
   levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
   QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
   sizePolicy.setHorizontalStretch(0);
   sizePolicy.setVerticalStretch(0);
   sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
   levelWindowWidget->setSizePolicy(sizePolicy);
   levelWindowWidget->setMaximumSize(QSize(50, 2000));
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //resize Image.
   this->resize( QSize(364, 477).expandedTo(minimumSizeHint()) );
 
   //Initialize the widgets.
   this->InitializeWidget();
 
   //Activate Widget Menu
   this->ActivateMenuWidget( true );
 }
 
 void QmitkStdMultiWidget::InitializeWidget()
 {
   m_PositionTracker = NULL;
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   QColor qcolor;
   //float color[3] = {1.0f,1.0f,1.0f};
   mitk::DataNode::Pointer planeNode;
   mitk::IntProperty::Pointer  layer;
 
   // of widget 1
-  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
+  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   planeNode->SetColor(1.0,0.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 2
-  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
+  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   planeNode->SetColor(0.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 3
-  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
+  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   planeNode->SetColor(0.0,0.0,1.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 4
-  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
+  planeNode = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   planeNode->SetColor(1.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New();
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetOverlayManager(OverlayManager);
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetOverlayManager(OverlayManager);
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetOverlayManager(OverlayManager);
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetOverlayManager(OverlayManager);
 
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   // Set plane mode (slicing/rotation behavior) to slicing (default)
   m_PlaneMode = PLANE_MODE_SLICING;
 
   // Set default view directions for SNCs
   mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Axial );
   mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Sagittal );
   mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Frontal );
   mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Original );
 
   /*************************************************/
   //Write Layout Names into the viewers -- hardCoded
 
   //Info for later:
   //int view = this->GetRenderWindow1()->GetSliceNavigationController()->GetDefaultViewDirection();
   //QString layoutName;
   //if( view == mitk::SliceNavigationController::Axial )
   //  layoutName = "Axial";
   //else if( view == mitk::SliceNavigationController::Sagittal )
   //  layoutName = "Sagittal";
   //else if( view == mitk::SliceNavigationController::Frontal )
   //  layoutName = "Coronal";
   //else if( view == mitk::SliceNavigationController::Original )
   //  layoutName = "Original";
   //if( view >= 0 && view < 4 )
   //  //write LayoutName --> Viewer 3D shoudn't write the layoutName.
 
   //Render Window 1 == axial
   m_CornerAnnotaions[0].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[0].cornerText->SetText(0, "Axial");
   m_CornerAnnotaions[0].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[0].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[0].textProp->SetColor( 1.0, 0.0, 0.0 );
   m_CornerAnnotaions[0].cornerText->SetTextProperty( m_CornerAnnotaions[0].textProp );
   m_CornerAnnotaions[0].ren = vtkRenderer::New();
   m_CornerAnnotaions[0].ren->AddActor(m_CornerAnnotaions[0].cornerText);
   m_CornerAnnotaions[0].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[0].ren,true);
 
   //Render Window 2 == sagittal
   m_CornerAnnotaions[1].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[1].cornerText->SetText(0, "Sagittal");
   m_CornerAnnotaions[1].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[1].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[1].textProp->SetColor( 0.0, 1.0, 0.0 );
   m_CornerAnnotaions[1].cornerText->SetTextProperty( m_CornerAnnotaions[1].textProp );
   m_CornerAnnotaions[1].ren = vtkRenderer::New();
   m_CornerAnnotaions[1].ren->AddActor(m_CornerAnnotaions[1].cornerText);
   m_CornerAnnotaions[1].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[1].ren,true);
 
   //Render Window 3 == coronal
   m_CornerAnnotaions[2].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[2].cornerText->SetText(0, "Coronal");
   m_CornerAnnotaions[2].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[2].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[2].textProp->SetColor( 0.295, 0.295, 1.0 );
   m_CornerAnnotaions[2].cornerText->SetTextProperty( m_CornerAnnotaions[2].textProp );
   m_CornerAnnotaions[2].ren = vtkRenderer::New();
   m_CornerAnnotaions[2].ren->AddActor(m_CornerAnnotaions[2].cornerText);
   m_CornerAnnotaions[2].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[2].ren,true);
 
   /*************************************************/
 
   // create a slice rotator
   // m_SlicesRotator = mitk::SlicesRotator::New();
   // @TODO next line causes sure memory leak
   // rotator will be created nonetheless (will be switched on and off)
   m_SlicesRotator = mitk::SlicesRotator::New("slices-rotator");
   m_SlicesRotator->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   // create a slice swiveller (using the same state-machine as SlicesRotator)
   m_SlicesSwiveller = mitk::SlicesSwiveller::New("slices-rotator");
   m_SlicesSwiveller->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   //connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget1->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget2->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget3->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget4->GetSliceNavigationController() , false);
   mitkWidget1->GetSliceNavigationController()
     ->ConnectGeometrySendEvent(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
 
   //reverse connection between sliceNavigationControllers and m_TimeNavigationController
   mitkWidget1->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget2->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget3->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget4->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
 
   m_LastLeftClickPositionSupplier =
     mitk::CoordinateSupplier::New("navigation", NULL);
   mitk::GlobalInteraction::GetInstance()->AddListener(
     m_LastLeftClickPositionSupplier
     );
   // setup gradient background
   m_GradientBackground1 = mitk::GradientBackground::New();
   m_GradientBackground1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_GradientBackground1->Disable();
 
   m_GradientBackground2 = mitk::GradientBackground::New();
   m_GradientBackground2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_GradientBackground2->Disable();
 
   m_GradientBackground3 = mitk::GradientBackground::New();
   m_GradientBackground3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_GradientBackground3->Disable();
 
   m_GradientBackground4 = mitk::GradientBackground::New();
   m_GradientBackground4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_GradientBackground4->SetGradientColors(0.1,0.1,0.1,0.5,0.5,0.5);
   m_GradientBackground4->Enable();
 
   // setup the department logo rendering
   m_LogoRendering1 = mitk::ManufacturerLogo::New();
   m_LogoRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_LogoRendering1->Disable();
 
   m_LogoRendering2 = mitk::ManufacturerLogo::New();
   m_LogoRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_LogoRendering2->Disable();
 
   m_LogoRendering3 = mitk::ManufacturerLogo::New();
   m_LogoRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_LogoRendering3->Disable();
 
   m_LogoRendering4 = mitk::ManufacturerLogo::New();
   m_LogoRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_LogoRendering4->Enable();
 
   m_RectangleRendering1 = mitk::RenderWindowFrame::New();
   m_RectangleRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_RectangleRendering1->Enable(1.0,0.0,0.0);
 
   m_RectangleRendering2 = mitk::RenderWindowFrame::New();
   m_RectangleRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_RectangleRendering2->Enable(0.0,1.0,0.0);
 
   m_RectangleRendering3 = mitk::RenderWindowFrame::New();
   m_RectangleRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_RectangleRendering3->Enable(0.0,0.0,1.0);
 
   m_RectangleRendering4 = mitk::RenderWindowFrame::New();
   m_RectangleRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_RectangleRendering4->Enable(1.0,1.0,0.0);
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   DisablePositionTracking();
   DisableNavigationControllerEventListening();
 
   m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
 
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[0].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[1].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[2].ren );
 
   //Delete CornerAnnotation
   m_CornerAnnotaions[0].cornerText->Delete();
   m_CornerAnnotaions[0].textProp->Delete();
   m_CornerAnnotaions[0].ren->Delete();
 
   m_CornerAnnotaions[1].cornerText->Delete();
   m_CornerAnnotaions[1].textProp->Delete();
   m_CornerAnnotaions[1].ren->Delete();
 
   m_CornerAnnotaions[2].cornerText->Delete();
   m_CornerAnnotaions[2].textProp->Delete();
   m_CornerAnnotaions[2].ren->Delete();
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if(m_DataStorage.IsNotNull())
     {
       m_DataStorage->Remove(m_PlaneNode1);
       m_DataStorage->Remove(m_PlaneNode2);
       m_DataStorage->Remove(m_PlaneNode3);
       m_DataStorage->Remove(m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(m_Node);
       m_DataStorage->Add(m_PlaneNode1, m_Node);
       m_DataStorage->Add(m_PlaneNode2, m_Node);
       m_DataStorage->Add(m_PlaneNode3, m_Node);
-      static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
-      static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
-      static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
+      static_cast<mitk::PlaneGeometryDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
+      static_cast<mitk::PlaneGeometryDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
+      static_cast<mitk::PlaneGeometryDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
 {
   SMW_INFO << "changing layout to 2D images up... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set SplitterSize for splitter top
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //Change Layout Name
   m_Layout = LAYOUT_2D_IMAGES_UP;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
 {
   SMW_INFO << "changing layout to 2D images left... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set splitterSize of SubSplit1
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitterSize of Layout Split
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //update Layout Name
   m_Layout = LAYOUT_2D_IMAGES_LEFT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToDefault()
 {
   SMW_INFO << "changing layout to default... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_SubSplit2->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_DEFAULT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_DEFAULT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToBig3D()
 {
   SMW_INFO << "changing layout to big 3D ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget4Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_BIG_3D;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_BIG_3D );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget1()
 {
   SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget1Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET1;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET1 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget2()
 {
   SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget2Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET2;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET2 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget3()
 {
   SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget3Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET3;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET3 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set SplitterSize
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   this->changeLayoutToRowWidget3And4();
 
   m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
 }
 
 void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit2->setSizes( splitterSize );
   splitterSize.clear();
   splitterSize.push_back(500);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
 {
   SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
 {
   SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget4Container );
   m_SubSplit2->addWidget( mitkWidget2Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
 {
   SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
 
   //set SplitterSize for splitter top
    QList<int> splitterSize;
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(700);
   splitterSize.push_back(700);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
 
   //update all Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::SetDataStorage( mitk::DataStorage* ds )
 {
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
   m_DataStorage = ds;
 }
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkRenderer * vtkrenderer;
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetDisplayGeometry()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::InitPositionTracking()
 {
   //PoinSetNode for MouseOrientation
   m_PositionTrackerNode = mitk::DataNode::New();
   m_PositionTrackerNode->SetProperty("name", mitk::StringProperty::New("Mouse Position"));
   m_PositionTrackerNode->SetData( mitk::PointSet::New() );
   m_PositionTrackerNode->SetColor(1.0,0.33,0.0);
   m_PositionTrackerNode->SetProperty("layer", mitk::IntProperty::New(1001));
   m_PositionTrackerNode->SetVisibility(true);
   m_PositionTrackerNode->SetProperty("inputdevice", mitk::BoolProperty::New(true) );
   m_PositionTrackerNode->SetProperty("BaseRendererMapperID", mitk::IntProperty::New(0) );//point position 2D mouse
   m_PositionTrackerNode->SetProperty("baserenderer", mitk::StringProperty::New("N/A"));
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   float white[3] = {1.0f,1.0f,1.0f};
-  mitk::Geometry2DDataMapper2D::Pointer mapper;
+  mitk::PlaneGeometryDataMapper2D::Pointer mapper;
 
   // ... of widget 1
-  m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
+  m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
-  mapper = mitk::Geometry2DDataMapper2D::New();
+  mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
-  m_PlaneNode2 =( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
+  m_PlaneNode2 =( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
-  mapper = mitk::Geometry2DDataMapper2D::New();
+  mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
-  m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
+  m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
-  mapper = mitk::Geometry2DDataMapper2D::New();
+  mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_Node = mitk::DataNode::New();
   m_Node->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_Node->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::EnableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
   levelWindowWidget->show();
 }
 
 void QmitkStdMultiWidget::DisableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->hide();
 }
 
 // CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
 // Use RenderingManager::InitializeViews() instead.
 bool QmitkStdMultiWidget::InitializeStandardViews( const mitk::Geometry3D * geometry )
 {
   return m_RenderingManager->InitializeViews( geometry );
 }
 
 void QmitkStdMultiWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
 }
 
 void QmitkStdMultiWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
 }
 
 void QmitkStdMultiWidget::wheelEvent( QWheelEvent * e )
 {
   emit WheelMoved( e );
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent * e)
 {
    if (e->button() == Qt::LeftButton) {
        mitk::Point3D pointValue = this->GetLastLeftClickPosition();
        emit LeftMouseClicked(pointValue);
    }
 }
 
 void QmitkStdMultiWidget::moveEvent( QMoveEvent* e )
 {
   QWidget::moveEvent( e );
 
   // it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::leaveEvent ( QEvent * /*e*/  )
 {
   //set cursor back to initial state
   m_SlicesRotator->ResetMouseCursor();
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return mitkWidget1;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return mitkWidget2;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return mitkWidget3;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return mitkWidget4;
 }
 
 const mitk::Point3D& QmitkStdMultiWidget::GetLastLeftClickPosition() const
 {
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
 {
   const mitk::PlaneGeometry *plane1 =
     mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 =
     mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 =
     mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ( (plane1 != NULL) && (plane2 != NULL)
     && (plane1->IntersectionLine( plane2, line )) )
   {
     mitk::Point3D point;
     if ( (plane3 != NULL)
       && (plane3->IntersectionPoint( line, point )) )
     {
       return point;
     }
   }
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 void QmitkStdMultiWidget::EnablePositionTracking()
 {
   if (!m_PositionTracker)
   {
     m_PositionTracker = mitk::PositionTracker::New("PositionTracker", NULL);
   }
   mitk::GlobalInteraction* globalInteraction = mitk::GlobalInteraction::GetInstance();
   if (globalInteraction)
   {
     if(m_DataStorage.IsNotNull())
       m_DataStorage->Add(m_PositionTrackerNode);
     globalInteraction->AddListener(m_PositionTracker);
   }
 }
 
 void QmitkStdMultiWidget::DisablePositionTracking()
 {
   mitk::GlobalInteraction* globalInteraction =
     mitk::GlobalInteraction::GetInstance();
 
   if(globalInteraction)
   {
     if (m_DataStorage.IsNotNull())
       m_DataStorage->Remove(m_PositionTrackerNode);
     globalInteraction->RemoveListener(m_PositionTracker);
   }
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(
   mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p)
 {
   mitk::Point2D pointOnPlane;
   displayGeometry->Map( p, pointOnPlane );
 
   // point minus origin < width or height ==> outside ?
   mitk::Vector2D pointOnRenderWindow_MM;
   pointOnRenderWindow_MM = pointOnPlane.GetVectorFromOrigin()
     - displayGeometry->GetOriginInMM();
 
   mitk::Vector2D sizeOfDisplay( displayGeometry->GetSizeInMM() );
 
   if (   sizeOfDisplay[0] < pointOnRenderWindow_MM[0]
   ||                0 > pointOnRenderWindow_MM[0]
   || sizeOfDisplay[1] < pointOnRenderWindow_MM[1]
   ||                0 > pointOnRenderWindow_MM[1] )
   {
     // point is not visible -> move geometry
     mitk::Vector2D offset( (pointOnRenderWindow_MM - sizeOfDisplay / 2.0)
       / displayGeometry->GetScaleFactorMMPerDisplayUnit() );
 
     displayGeometry->MoveBy( offset );
   }
 }
 
 void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D& newPosition)
 {
   // create a PositionEvent with the given position and
   // tell the slice navigation controllers to move there
 
   mitk::Point2D p2d;
   mitk::PositionEvent event( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()), 0, 0, 0,
     mitk::Key_unknown, p2d, newPosition );
   mitk::StateEvent stateEvent(mitk::EIDLEFTMOUSEBTN, &event);
   mitk::StateEvent stateEvent2(mitk::EIDLEFTMOUSERELEASE, &event);
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesRotator->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesSwiveller->HandleEvent( &stateEvent2 );
     break;
   }
 
   // determine if cross is now out of display
   // if so, move the display window
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
 
   // update displays
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
 {
   if(!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent=true;
     QTimer::singleShot(0,this,SLOT( HandleCrosshairPositionEventDelayed() ) );
   }
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
 {
   mitk::Point3D crosshairPos = this->GetCrossPosition();
   mitk::DataNode::Pointer node;
   int  maxlayer = -32768;
 
   if(nodes.IsNotNull())
   {
     mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
     // find node with largest layer, that is the node shown on top in the render window
     for (unsigned int x = 0; x < nodes->size(); x++)
     {
     if ( (nodes->at(x)->GetData()->GetGeometry() != NULL) &&
          nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos) )
     {
       int layer = 0;
       if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
       if(layer > maxlayer)
       {
         if( static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible( baseRenderer ) )
         {
           node = nodes->at(x);
           maxlayer = layer;
         }
       }
     }
     }
   }
   return node;
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
 
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
 
   mitk::DataNode::Pointer node;
   mitk::DataNode::Pointer topSourceNode;
   mitk::Image::Pointer image;
   bool isBinary = false;
   node = this->GetTopLayerNode(nodes);
   if(node.IsNotNull())
   {
     node->GetBoolProperty("binary",isBinary);
     if(isBinary)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true);
       if(!sourcenodes->empty())
       {
         topSourceNode = this->GetTopLayerNode(sourcenodes);
       }
       if(topSourceNode.IsNotNull())
       {
         image = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
       }
       else
       {
         image = dynamic_cast<mitk::Image*>(node->GetData());
       }
     }
     else
     {
       image = dynamic_cast<mitk::Image*>(node->GetData());
     }
   }
 
   mitk::Point3D crosshairPos = this->GetCrossPosition();
   std::string statusText;
   std::stringstream stream;
   mitk::Index3D p;
   mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
   unsigned int timestep = baseRenderer->GetTimeStep();
 
   if(image.IsNotNull() && (image->GetTimeSteps() > timestep ))
   {
     image->GetGeometry()->WorldToIndex(crosshairPos, p);
     stream.precision(2);
     stream<<"Position: <" << std::fixed <<crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", " << std::fixed << crosshairPos[2] << "> mm";
     stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
     mitk::ScalarType pixelValue = image->GetPixelValueByIndex(p, timestep);
     if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
     {
       stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< std::scientific<< pixelValue <<"  ";
     }
     else
     {
       stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<"  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 }
 
 void QmitkStdMultiWidget::EnableNavigationControllerEventListening()
 {
   // Let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Listen for SliceNavigationController
   mitkWidget1->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget2->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget3->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
 
   gi->AddListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = true;
 }
 
 void QmitkStdMultiWidget::DisableNavigationControllerEventListening()
 {
   // Do not let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   gi->RemoveListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = false;
 }
 
 int QmitkStdMultiWidget::GetLayout() const
 {
   return m_Layout;
 }
 
 bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
 {
   return m_GradientBackgroundFlag;
 }
 
 void QmitkStdMultiWidget::EnableGradientBackground()
 {
   // gradient background is by default only in widget 4, otherwise
   // interferences between 2D rendering and VTK rendering may occur.
   //m_GradientBackground1->Enable();
   //m_GradientBackground2->Enable();
   //m_GradientBackground3->Enable();
   m_GradientBackground4->Enable();
   m_GradientBackgroundFlag = true;
 }
 
 void QmitkStdMultiWidget::DisableGradientBackground()
 {
   //m_GradientBackground1->Disable();
   //m_GradientBackground2->Disable();
   //m_GradientBackground3->Disable();
   m_GradientBackground4->Disable();
   m_GradientBackgroundFlag = false;
 }
 
 void QmitkStdMultiWidget::EnableDepartmentLogo()
 {
   m_LogoRendering4->Enable();
 }
 
 void QmitkStdMultiWidget::DisableDepartmentLogo()
 {
   m_LogoRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
 {
   return m_LogoRendering4->IsEnabled();
 }
 
 bool QmitkStdMultiWidget::IsCrosshairNavigationEnabled() const
 {
   return m_CrosshairNavigationEnabled;
 }
 
 mitk::SlicesRotator * QmitkStdMultiWidget::GetSlicesRotator() const
 {
   return m_SlicesRotator;
 }
 
 mitk::SlicesSwiveller * QmitkStdMultiWidget::GetSlicesSwiveller() const
 {
   return m_SlicesSwiveller;
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char* widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_DataStorage.IsNotNull())
   {
     mitk::DataNode* n = m_DataStorage->GetNamedNode(widgetName);
     if (n != NULL)
       n->SetVisibility(visible, renderer);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   SetWidgetPlaneVisibility("widget1Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget2Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget3Plane", visible, renderer);
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked( bool link )
 {
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
   emit WidgetPlanesRotationLinked( link );
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode( int userMode )
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   // first of all reset left mouse button interaction to default if PACS interaction style is active
   m_MouseModeSwitcher->SelectMouseMode( mitk::MouseModeSwitcher::MousePointer );
 
   emit WidgetNotifyNewCrossHairMode( userMode );
 
   int mode = m_PlaneMode;
   bool link = false;
 
   // Convert user interface mode to actual mode
   {
     switch(userMode)
     {
       case 0:
         mode = PLANE_MODE_SLICING;
         link = false;
         break;
 
       case 1:
         mode = PLANE_MODE_ROTATION;
         link = false;
         break;
 
       case 2:
         mode = PLANE_MODE_ROTATION;
         link = true;
         break;
 
       case 3:
         mode = PLANE_MODE_SWIVEL;
         link = false;
         break;
     }
   }
 
   // Slice rotation linked
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
 
   // Do nothing if mode didn't change
   if ( m_PlaneMode == mode )
   {
     return;
   }
 
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Remove listeners of previous mode
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSlicing( false );
 
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeRotation( false );
 
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSwivel( false );
 
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   // Set new mode and add corresponding listener to GlobalInteraction
   m_PlaneMode = mode;
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSlicing( true );
 
     // Add listeners
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
 
     m_RenderingManager->InitializeViews();
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeRotation( true );
 
     // Add listener
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSwivel( true );
 
     // Add listener
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
   // Notify MainTemplate GUI that mode has changed
   emit WidgetPlaneModeChange(m_PlaneMode);
 }
 
 void QmitkStdMultiWidget::SetGradientBackgroundColors( const mitk::Color & upper, const mitk::Color & lower )
 {
   m_GradientBackground1->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground2->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground3->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground4->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackgroundFlag = true;
 }
 
 void QmitkStdMultiWidget::SetDepartmentLogoPath( const char * path )
 {
   m_LogoRendering1->SetLogoSource(path);
   m_LogoRendering2->SetLogoSource(path);
   m_LogoRendering3->SetLogoSource(path);
   m_LogoRendering4->SetLogoSource(path);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SLICING );
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_ROTATION );
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SWIVEL );
   }
 }
 
 void QmitkStdMultiWidget::OnLayoutDesignChanged( int layoutDesignIndex )
 {
   switch( layoutDesignIndex )
   {
   case LAYOUT_DEFAULT:
     {
       this->changeLayoutToDefault();
       break;
     }
   case LAYOUT_2D_IMAGES_UP:
     {
       this->changeLayoutTo2DImagesUp();
       break;
     }
   case LAYOUT_2D_IMAGES_LEFT:
     {
       this->changeLayoutTo2DImagesLeft();
       break;
     }
   case LAYOUT_BIG_3D:
     {
       this->changeLayoutToBig3D();
       break;
     }
   case LAYOUT_WIDGET1:
     {
       this->changeLayoutToWidget1();
       break;
     }
   case LAYOUT_WIDGET2:
     {
       this->changeLayoutToWidget2();
       break;
     }
   case LAYOUT_WIDGET3:
     {
       this->changeLayoutToWidget3();
       break;
     }
   case LAYOUT_2X_2D_AND_3D_WIDGET:
     {
       this->changeLayoutTo2x2Dand3DWidget();
       break;
     }
   case LAYOUT_ROW_WIDGET_3_AND_4:
     {
       this->changeLayoutToRowWidget3And4();
       break;
     }
   case LAYOUT_COLUMN_WIDGET_3_AND_4:
     {
       this->changeLayoutToColumnWidget3And4();
       break;
     }
   case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
     {
       this->changeLayoutToRowWidgetSmall3andBig4();
       break;
     }
   case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
     {
       this->changeLayoutToSmallUpperWidget2Big3and4();
       break;
     }
   case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
     {
       this->changeLayoutToLeft2Dand3DRight2D();
       break;
     }
   };
 }
 
 void QmitkStdMultiWidget::UpdateAllWidgets()
 {
   mitkWidget1->resize( mitkWidget1Container->frameSize().width()-1, mitkWidget1Container->frameSize().height() );
   mitkWidget1->resize( mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height() );
 
   mitkWidget2->resize( mitkWidget2Container->frameSize().width()-1, mitkWidget2Container->frameSize().height() );
   mitkWidget2->resize( mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height() );
 
   mitkWidget3->resize( mitkWidget3Container->frameSize().width()-1, mitkWidget3Container->frameSize().height() );
   mitkWidget3->resize( mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height() );
 
   mitkWidget4->resize( mitkWidget4Container->frameSize().width()-1, mitkWidget4Container->frameSize().height() );
   mitkWidget4->resize( mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height() );
 }
 
 void QmitkStdMultiWidget::HideAllWidgetToolbars()
 {
   mitkWidget1->HideRenderWindowMenu();
   mitkWidget2->HideRenderWindowMenu();
   mitkWidget3->HideRenderWindowMenu();
   mitkWidget4->HideRenderWindowMenu();
 }
 
 void QmitkStdMultiWidget::ActivateMenuWidget( bool state )
 {
   mitkWidget1->ActivateMenuWidget( state, this );
   mitkWidget2->ActivateMenuWidget( state, this );
   mitkWidget3->ActivateMenuWidget( state, this );
   mitkWidget4->ActivateMenuWidget( state, this );
 }
 
 bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
 {
   return mitkWidget1->GetActivateMenuWidgetFlag();
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   if (m_DataStorage.IsNotNull())
   {
     m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage);
     //m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
     // reset interactor to normal slicing
     this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
   }
 }
 
 void QmitkStdMultiWidget::EnableColoredRectangles()
 {
   m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
   m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
   m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
   m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
 }
 
 void QmitkStdMultiWidget::DisableColoredRectangles()
 {
   m_RectangleRendering1->Disable();
   m_RectangleRendering2->Disable();
   m_RectangleRendering3->Disable();
   m_RectangleRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
 {
   return m_RectangleRendering1->IsEnabled();
 }
 
 mitk::MouseModeSwitcher* QmitkStdMultiWidget::GetMouseModeSwitcher()
 {
   return m_MouseModeSwitcher;
 }
 
 void QmitkStdMultiWidget::MouseModeSelected( mitk::MouseModeSwitcher::MouseMode mouseMode )
 {
   if ( mouseMode == 0 )
   {
     this->EnableNavigationControllerEventListening();
   }
   else
   {
     this->DisableNavigationControllerEventListening();
   }
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
 {
   return this->m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
 {
   return this->m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
 {
   return this->m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
 {
   switch(id)
   {
     case 1: return this->m_PlaneNode1;
     break;
     case 2: return this->m_PlaneNode2;
     break;
     case 3: return this->m_PlaneNode3;
     break;
     default: return NULL;
   }
 }
\ No newline at end of file
diff --git a/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp b/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
index 937b3e8e57..2c98b3808d 100644
--- a/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
+++ b/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
@@ -1,266 +1,266 @@
 /*===================================================================
 
 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 "mitkDataNodeFactory.h"
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkBaseProperty.h"
 #include "mitkProperties.h"
 #include <mitkAnnotationProperty.h>
 #include <mitkClippingProperty.h>
 #include <mitkColorProperty.h>
 #include <mitkEnumerationProperty.h>
 /*
 #include <mitkGridRepresentationProperty.h>
 #include <mitkGridVolumeMapperProperty.h>
 #include <mitkOrganTypeProperty.h>
 */
 #include <mitkModalityProperty.h>
 //#include <mitkOdfNormalizationMethodProperty.h>
 //#include <mitkOdfScaleByProperty.h>
 #include <mitkPlaneOrientationProperty.h>
 #include <mitkShaderProperty.h>
 #include <mitkVtkInterpolationProperty.h>
 #include <mitkVtkRepresentationProperty.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkVtkScalarModeProperty.h>
 #include <mitkVtkVolumeRenderingProperty.h>
 #include <mitkGroupTagProperty.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkStringProperty.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include "mitkPropertyList.h"
 #include "mitkPropertyListSerializer.h"
 #include "mitkBasePropertySerializer.h"
 
 #include <mitkPointSet.h>
 #include <mitkImage.h>
 #include <mitkSurface.h>
 #include <mitkVtkWidgetRendering.h>
 
 /*
 #include <mitkContour.h>
 #include <mitkContourSet.h>
 #include <mitkMesh.h>
 #include <mitkCone.h>
 #include <mitkCuboid.h>
 #include <mitkCylinder.h>
 #include <mitkEllipsoid.h>
 #include <mitkExtrudedContour.h>
 #include <mitkPlane.h>
 #include <mitkUnstructuredGrid.h>
 */
 
 void TestAllProperties(const mitk::PropertyList* propList);
 
 /**Documentation
 * \brief Test for all PropertySerializer classes.
 *
 */
 int mitkPropertySerializationTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("PropertySerializationTest");
 
   mitk::PropertyListSerializer::Pointer serializer = mitk::PropertyListSerializer::New(); // make sure something from the lib is actually used (registration of serializers)
 
   /* build list of properties that will be serialized and deserialized */
   mitk::PropertyList::Pointer propList = mitk::PropertyList::New();
   propList->SetProperty("booltrue", mitk::BoolProperty::New(true));
   propList->SetProperty("boolfalse", mitk::BoolProperty::New(false));
   propList->SetProperty("int", mitk::IntProperty::New(-32));
   propList->SetProperty("float", mitk::FloatProperty::New(-31.337));
   propList->SetProperty("double", mitk::DoubleProperty::New(-31.337));
   propList->SetProperty("string", mitk::StringProperty::New("Hello MITK"));
   mitk::Point3D p3d;
   mitk::FillVector3D(p3d, 1.0, 2.2, -3.3);
   propList->SetProperty("p3d", mitk::Point3dProperty::New(p3d));
   mitk::Point3I p3i;
   mitk::FillVector3D(p3i, 1, 2, -3);
   propList->SetProperty("p3i", mitk::Point3iProperty::New(p3i));
   mitk::Point4D p4d;
   mitk::FillVector4D(p4d, 1.5, 2.6, -3.7, 4.44);
   propList->SetProperty("p4d", mitk::Point4dProperty::New(p4d));
   mitk::Vector3D v3d;
   mitk::FillVector3D(v3d, 1.0, 2.2, -3.3);
   propList->SetProperty("v3d", mitk::Vector3DProperty::New(v3d));
   propList->SetProperty("annotation", mitk::AnnotationProperty::New("My Annotation", p3d));
   propList->SetProperty("clipping", mitk::ClippingProperty::New(p3d, v3d));
   propList->SetProperty("color", mitk::ColorProperty::New(1.0, 0.2, 0.2));
   //mitk::EnumerationProperty::Pointer en = mitk::EnumerationProperty::New();
   //en->AddEnum("PC", 1); en->AddEnum("Playstation", 2); en->AddEnum("Wii", 111); en->AddEnum("XBox", 7);
   //en->SetValue("XBox");
   //propList->SetProperty("enum", en);
   /*
   propList->SetProperty("gridrep", mitk::GridRepresentationProperty::New(2));
   propList->SetProperty("gridvol", mitk::GridVolumeMapperProperty::New(0));
   propList->SetProperty("OrganTypeProperty", mitk::OrganTypeProperty::New("Larynx"));
   */
   propList->SetProperty("modality", mitk::ModalityProperty::New("Color Doppler"));
   //propList->SetProperty("OdfNormalizationMethodProperty", mitk::OdfNormalizationMethodProperty::New("Global Maximum"));
   //propList->SetProperty("OdfScaleByProperty", mitk::OdfScaleByProperty::New("Principal Curvature"));
   propList->SetProperty("PlaneOrientationProperty", mitk::PlaneOrientationProperty::New("Arrows in positive direction"));
   propList->SetProperty("ShaderProperty", mitk::ShaderProperty::New("fixed"));
   propList->SetProperty("VtkInterpolationProperty", mitk::VtkInterpolationProperty::New("Gouraud"));
   propList->SetProperty("VtkRepresentationProperty", mitk::VtkRepresentationProperty::New("Surface"));
   propList->SetProperty("VtkResliceInterpolationProperty", mitk::VtkResliceInterpolationProperty::New("Cubic"));
   propList->SetProperty("VtkScalarModeProperty", mitk::VtkScalarModeProperty::New("PointFieldData"));
   propList->SetProperty("VtkVolumeRenderingProperty", mitk::VtkVolumeRenderingProperty::New("COMPOSITE"));
   mitk::BoolLookupTable blt;
   blt.SetTableValue(0, true);  blt.SetTableValue(1, false);  blt.SetTableValue(2, true);
   propList->SetProperty("BoolLookupTableProperty", mitk::BoolLookupTableProperty::New(blt));
   mitk::FloatLookupTable flt;
   flt.SetTableValue(0, 3.1);  flt.SetTableValue(1, 3.3);  flt.SetTableValue(2, 7.0);
   propList->SetProperty("FloatLookupTableProperty", mitk::FloatLookupTableProperty::New(flt));
   mitk::IntLookupTable ilt;
   ilt.SetTableValue(0, 3);  ilt.SetTableValue(1, 2);  ilt.SetTableValue(2, 11);
   propList->SetProperty("IntLookupTableProperty", mitk::IntLookupTableProperty::New(ilt));
   mitk::StringLookupTable slt;
   slt.SetTableValue(0, "Hello");  slt.SetTableValue(1, "MITK");  slt.SetTableValue(2, "world");
   propList->SetProperty("StringLookupTableProperty", mitk::StringLookupTableProperty::New(slt));
   propList->SetProperty("GroupTagProperty", mitk::GroupTagProperty::New());
   propList->SetProperty("LevelWindowProperty", mitk::LevelWindowProperty::New(mitk::LevelWindow(100.0, 50.0)));
   mitk::LookupTable::Pointer lt = mitk::LookupTable::New();
   lt->ChangeOpacityForAll(0.25);
   lt->ChangeOpacity(17, 0.88);
   propList->SetProperty("LookupTableProperty", mitk::LookupTableProperty::New(lt));
   propList->SetProperty("StringProperty", mitk::StringProperty::New("Oh why, gruel world"));
   //mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
   //tf->SetTransferFunctionMode(1);
   //propList->SetProperty("TransferFunctionProperty", mitk::TransferFunctionProperty::New(tf));
 
 
   MITK_TEST_CONDITION_REQUIRED(propList->GetMap()->size() > 0, "Initialize PropertyList");
 
   TestAllProperties(propList);
 
   /* test default property lists of basedata objects */
   // activate the following tests after MaterialProperty is deleted
 
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(mitk::PointSet::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Image::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Surface::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::VtkWidgetRendering::New());
   TestAllProperties(node->GetPropertyList());
 
   /*
   node->SetData(mitk::Contour::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::ContourSet::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Mesh::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Cone::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Cuboid::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Cylinder::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Ellipsoid::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::ExtrudedContour::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Plane::New());
   TestAllProperties(node->GetPropertyList());
   //node->SetData(mitk::TrackingVolume::New());  // TrackingVolume is in IGT Module, it does not have special properties, therefore we skip it here
   //TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::UnstructuredGrid::New());
   TestAllProperties(node->GetPropertyList());
   */
 
 /* untested base data types:
   BaseDataTestImplementation
   RenderWindowFrame
   mitk::DiffusionImage< TPixelType >
   GeometryData
-  mitk::Geometry2DData
+  mitk::PlaneGeometryData
   GradientBackground
   ItkBaseDataAdapter
   ManufacturerLogo
   SlicedData
   QBallImage
   SeedsImage
   TensorImage
   BoundingObject
   BoundingObjectGroup
   */
 
   MITK_TEST_END();
 }
 
 void TestAllProperties(const mitk::PropertyList* propList)
 {
   assert(propList);
 
   /* try to serialize each property in the list, then deserialize again and check for equality */
   for (mitk::PropertyList::PropertyMap::const_iterator it = propList->GetMap()->begin(); it != propList->GetMap()->end(); ++it)
   {
     const mitk::BaseProperty* prop = it->second;
     // construct name of serializer class
     std::string serializername = std::string(prop->GetNameOfClass()) + "Serializer";
     std::list<itk::LightObject::Pointer> allSerializers = itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
     MITK_TEST_CONDITION(allSerializers.size() > 0, std::string("Creating serializers for ") + serializername);
     if (allSerializers.size() == 0)
     {
       MITK_TEST_OUTPUT( << "serialization not possible, skipping " << prop->GetNameOfClass());
       continue;
     }
     if (allSerializers.size() > 1)
     {
       MITK_TEST_OUTPUT (<< "Warning: " << allSerializers.size() << " serializers found for " << prop->GetNameOfClass() << "testing only the first one.");
     }
     mitk::BasePropertySerializer* serializer = dynamic_cast<mitk::BasePropertySerializer*>( allSerializers.begin()->GetPointer());
     MITK_TEST_CONDITION(serializer != NULL, serializername + std::string(" is valid"));
     if (serializer != NULL)
     {
       serializer->SetProperty(prop);
       TiXmlElement* valueelement = NULL;
       try
       {
         valueelement = serializer->Serialize();
       }
       catch (...)
       {
       }
       MITK_TEST_CONDITION(valueelement != NULL, std::string("Serialize property with ") + serializername);
 
       if (valueelement == NULL)
       {
         MITK_TEST_OUTPUT( << "serialization failed, skipping deserialization");
         continue;
       }
 
       mitk::BaseProperty::Pointer deserializedProp = serializer->Deserialize( valueelement );
       MITK_TEST_CONDITION(deserializedProp.IsNotNull(), "serializer created valid property");
       if (deserializedProp.IsNotNull())
       {
         MITK_TEST_CONDITION(*(deserializedProp.GetPointer()) == *prop, "deserialized property equals initial property for type " << prop->GetNameOfClass());
       }
 
     }
     else
     {
       MITK_TEST_OUTPUT( << "created serializer object is of class " << allSerializers.begin()->GetPointer()->GetNameOfClass())
     }
   } // for all properties
 }
diff --git a/Modules/Segmentation/Interactions/mitkContourTool.cpp b/Modules/Segmentation/Interactions/mitkContourTool.cpp
index d50bc8e081..1346febe80 100644
--- a/Modules/Segmentation/Interactions/mitkContourTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourTool.cpp
@@ -1,187 +1,187 @@
 /*===================================================================
 
 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 "mitkContourTool.h"
 
 #include "mitkToolManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 //#include "mitkProperties.h"
 //#include "mitkPlanarCircle.h"
 
 #include "mitkStateMachineAction.h"
 #include "mitkInteractionEvent.h"
 
 mitk::ContourTool::ContourTool(int paintingPixelValue)
 :FeedbackContourTool("PressMoveReleaseWithCTRLInversion"),
  m_PaintingPixelValue(paintingPixelValue)
 {
 }
 
 mitk::ContourTool::~ContourTool()
 {
 }
 
 void mitk::ContourTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION( "PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION( "Move", OnMouseMoved);
   CONNECT_FUNCTION( "Release", OnMouseReleased);
   CONNECT_FUNCTION( "InvertLogic", OnInvertLogic);
 }
 
 void mitk::ContourTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::ContourTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 /**
  Just show the contour, insert the first point.
 */
 bool mitk::ContourTool::OnMousePressed( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(interactionEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
 //  if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   ContourModel* contour = FeedbackContourTool::GetFeedbackContour();
   //Clear feedback contour
   contour->Initialize();
   //expand time bounds because our contour was initialized
   contour->Expand( timestep + 1 );
   //draw as a closed contour
   contour->SetClosed(true,timestep);
   //add first mouse position
   mitk::Point3D point = positionEvent->GetPositionInWorld();
   contour->AddVertex( point, timestep );
 
   FeedbackContourTool::SetFeedbackContourVisible(true);
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 /**
  Insert the point to the feedback contour.
 */
 bool mitk::ContourTool::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   //if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   ContourModel* contour = FeedbackContourTool::GetFeedbackContour();
   mitk::Point3D point = positionEvent->GetPositionInWorld();
   contour->AddVertex( point, timestep );
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 /**
   Close the contour, project it to the image slice and fill it in 2D.
 */
 bool mitk::ContourTool::OnMouseReleased( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   // 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's working image corresponds to that
   FeedbackContourTool::SetFeedbackContourVisible(false);
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   //if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if (!workingNode) return false;
 
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
-  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
   if ( !image || !planeGeometry ) return false;
 
     // 2. Slice is known, now we try to get it as a 2D image and project the contour into index coordinates of this slice
     Image::Pointer slice = SegTool2D::GetAffectedImageSliceAs2DImage( positionEvent, image );
 
     if ( slice.IsNull() )
     {
       MITK_ERROR << "Unable to extract slice." << std::endl;
       return false;
     }
 
     ContourModel* feedbackContour = FeedbackContourTool::GetFeedbackContour();
     ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice( slice, feedbackContour, true, false ); // true: actually no idea why this is neccessary, but it works :-(
 
     if (projectedContour.IsNull()) return false;
 
     int timestep = positionEvent->GetSender()->GetTimeStep();
 
     FeedbackContourTool::FillContourInSlice( projectedContour, timestep, slice, m_PaintingPixelValue );
 
     this->WriteBackSegmentationResult(positionEvent, slice);
 
     // 4. Make sure the result is drawn again --> is visible then.
     assert( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 /**
   Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
 */
 bool mitk::ContourTool::OnInvertLogic( StateMachineAction*, InteractionEvent* interactionEvent )
 {
  // if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   // Inversion only for 0 and 1 as painting values
   if (m_PaintingPixelValue == 1)
   {
     m_PaintingPixelValue = 0;
     FeedbackContourTool::SetFeedbackContourColor( 1.0, 0.0, 0.0 );
   }
   else if (m_PaintingPixelValue == 0)
   {
     m_PaintingPixelValue = 1;
     FeedbackContourTool::SetFeedbackContourColorDefault();
   }
 
   return true;
 }
 
diff --git a/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp b/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
index c76f5951b0..265382a55d 100644
--- a/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
@@ -1,195 +1,195 @@
 /*===================================================================
 
 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 "mitkCorrectorTool2D.h"
 #include "mitkCorrectorAlgorithm.h"
 
 #include "mitkToolManager.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkImageReadAccessor.h"
 
 #include "mitkCorrectorTool2D.xpm"
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(MitkSegmentation_EXPORT, CorrectorTool2D, "Correction tool");
 }
 
 mitk::CorrectorTool2D::CorrectorTool2D(int paintingPixelValue)
 :FeedbackContourTool("PressMoveRelease"),
  m_PaintingPixelValue(paintingPixelValue)
 {
   GetFeedbackContour()->SetClosed( false ); // don't close the contour to a polygon
 }
 
 mitk::CorrectorTool2D::~CorrectorTool2D()
 {
 }
 
 void mitk::CorrectorTool2D::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION( "PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION( "Move", OnMouseMoved);
   CONNECT_FUNCTION( "Release", OnMouseReleased);
 }
 
 const char** mitk::CorrectorTool2D::GetXPM() const
 {
   return mitkCorrectorTool2D_xpm;
 }
 
 us::ModuleResource mitk::CorrectorTool2D::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Correction_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::CorrectorTool2D::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Correction_Cursor_32x32.png");
   return resource;
 }
 
 const char* mitk::CorrectorTool2D::GetName() const
 {
   return "Correction";
 }
 
 void mitk::CorrectorTool2D::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::CorrectorTool2D::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 bool mitk::CorrectorTool2D::OnMousePressed ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   //if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
   ContourModel* contour = FeedbackContourTool::GetFeedbackContour();
   contour->Clear();
   contour->Expand(timestep + 1);
   contour->SetClosed(false, timestep);
   mitk::Point3D point = positionEvent->GetPositionInWorld();
   contour->AddVertex( point, timestep );
 
   FeedbackContourTool::SetFeedbackContourVisible(true);
 
   return true;
 }
 
 bool mitk::CorrectorTool2D::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   //if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
   ContourModel* contour = FeedbackContourTool::GetFeedbackContour();
   mitk::Point3D point = positionEvent->GetPositionInWorld();
   contour->AddVertex( point, timestep );
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 bool mitk::CorrectorTool2D::OnMouseReleased( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   // 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's working image corresponds to that
   FeedbackContourTool::SetFeedbackContourVisible(false);
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   //if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if (!workingNode) return false;
 
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
-  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
   if ( !image || !planeGeometry ) return false;
 
   // 2. Slice is known, now we try to get it as a 2D image and project the contour into index coordinates of this slice
   m_WorkingSlice = FeedbackContourTool::GetAffectedImageSliceAs2DImage( positionEvent, image );
 
   if ( m_WorkingSlice.IsNull() )
   {
       MITK_ERROR << "Unable to extract slice." << std::endl;
       return false;
   }
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
   mitk::ContourModel::Pointer singleTimestepContour = mitk::ContourModel::New();
 
   mitk::ContourModel::VertexIterator it = FeedbackContourTool::GetFeedbackContour()->Begin(timestep);
   mitk::ContourModel::VertexIterator end = FeedbackContourTool::GetFeedbackContour()->End(timestep);
 
   while(it!=end)
   {
     singleTimestepContour->AddVertex((*it)->Coordinates);
     it++;
   }
 
   CorrectorAlgorithm::Pointer algorithm = CorrectorAlgorithm::New();
   algorithm->SetInput( m_WorkingSlice );
   algorithm->SetContour( singleTimestepContour );
   try
   {
       algorithm->UpdateLargestPossibleRegion();
   }
   catch ( std::exception& e )
   {
       MITK_ERROR << "Caught exception '" << e.what() << "'" << std::endl;
   }
 
   mitk::Image::Pointer resultSlice = mitk::Image::New();
   resultSlice->Initialize(algorithm->GetOutput());
   mitk::ImageReadAccessor imAccess(algorithm->GetOutput());
   resultSlice->SetVolume(imAccess.GetData());
 
   this->WriteBackSegmentationResult(positionEvent, resultSlice);
 
   return true;
 }
 
diff --git a/Modules/Segmentation/Interactions/mitkExtrudedContourInteractor.cpp b/Modules/Segmentation/Interactions/mitkExtrudedContourInteractor.cpp
index 020f50dd4c..ee7cf45a26 100644
--- a/Modules/Segmentation/Interactions/mitkExtrudedContourInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkExtrudedContourInteractor.cpp
@@ -1,201 +1,201 @@
 /*===================================================================
 
 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 "mitkExtrudedContourInteractor.h"
 
 #include <mitkContour.h>
 #include <mitkExtrudedContour.h>
 
 #include <mitkStateEvent.h>
 #include <mitkUndoController.h>
 #include <mitkProperties.h>
 #include <mitkStringProperty.h>
 #include <mitkPointOperation.h>
 #include <mitkAction.h>
 #include <mitkPositionEvent.h>
 #include <mitkInteractionConst.h>
 #include <mitkPositionEvent.h>
 #include <mitkVtkPropRenderer.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkVtkRepresentationProperty.h>
 
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 
 mitk::ExtrudedContourInteractor::ExtrudedContourInteractor(const char * type, mitk::DataNode* dataNode)
   : mitk::Interactor(type, dataNode), m_Started(false)
 {
   assert(m_DataNode != NULL);
 
   m_DataNode->SetProperty( "material.representation", mitk::VtkRepresentationProperty::New("surface") );
 
   m_Contour = mitk::Contour::New();
 
   m_ContourNode = mitk::DataNode::New();
   m_ContourNode->SetData(m_Contour);
 
   m_ContourNode->SetProperty("layer", mitk::IntProperty::New(100) );
   m_ContourNode->SetProperty("name", mitk::StringProperty::New("InteractiveFeedbackData") );
   m_ContourNode->SetOpacity(1);
   m_ContourNode->SetColor(0.4,0.9,0.0);
   m_ContourNode->SetProperty( "Width", mitk::FloatProperty::New(2.0) );
   m_Started = false;
 }
 
 mitk::ExtrudedContourInteractor::~ExtrudedContourInteractor()
 {
 
 }
 
 //mitk::Contour::Pointer ExtrudedContourInteractor::ExtractContour(mitkIpPicDescriptor* pic)
 //{
 //  int idx;
 //  int size = _mitkIpPicElements (pic);
 //  for (idx = 0; idx < size; idx++)
 //    if ( ((mitkIpUInt1_t*) pic->data)[idx]> 0) break;
 //
 //  int sizePoints;  // size of the _points buffer (number of coordinate pairs that fit in)
 //  int numPoints;    // number of coordinate pairs stored in _points buffer
 //  float *points = 0;
 //
 //  points = ipSegmentationGetContour8N( pic, idx, numPoints, sizePoints, points );
 //
 //  mitk::Contour::Pointer m_Contour = mitk::Contour::New();
 //  m_Contour->Initialize();
 //  mitk::Point3D pointInMM, pointInUnits;
 //  mitk::Point3D itkPoint;
 //  for (int pointIdx = 0; pointIdx < numPoints; pointIdx++)
 //  {
 //    pointInUnits[0] = points[2*pointIdx];
 //    pointInUnits[1] = points[2*pointIdx+1];
 //    pointInUnits[2] = m_ZCoord;
 //    m_SelectedImageGeometry->IndexToWorld(CorrectPointCoordinates(pointInUnits),pointInMM);
 //    m_Contour->AddVertex(pointInMM);
 //  }
 //  return m_Contour;
 //}
 
 bool mitk::ExtrudedContourInteractor::ExecuteAction(mitk::Action* action, mitk::StateEvent const* stateEvent)
 {
   mitk::Point3D eventPoint;
   mitk::Vector3D eventPlaneNormal;
 
   const mitk::PositionEvent* posEvent = dynamic_cast<const mitk::PositionEvent*>(stateEvent->GetEvent());
 
   if(posEvent==NULL)
   {
     const mitk::DisplayPositionEvent* displayPosEvent = dynamic_cast<const mitk::DisplayPositionEvent*>(stateEvent->GetEvent());
     mitk::VtkPropRenderer* sender = (mitk::VtkPropRenderer*) stateEvent->GetEvent()->GetSender();
 
     if((displayPosEvent == NULL) || (sender == NULL))
       return false;
 
     eventPoint[0] = displayPosEvent->GetDisplayPosition()[0];
     eventPoint[1] = displayPosEvent->GetDisplayPosition()[1];
     eventPoint[2] = 0;
 
     typedef itk::Point<double,3> DoublePoint3D;
     DoublePoint3D p;
     p.CastFrom(eventPoint);
     sender->GetVtkRenderer()->SetDisplayPoint(p.GetDataPointer());
 
     sender->GetVtkRenderer()->DisplayToWorld();
 
     double *vtkwp = sender->GetVtkRenderer()->GetWorldPoint();
 
     vtk2itk(vtkwp, eventPoint);
 
     double *vtkvpn = sender->GetVtkRenderer()->GetActiveCamera()->GetViewPlaneNormal();
     vtk2itk(vtkvpn, eventPlaneNormal); eventPlaneNormal = -eventPlaneNormal;
   }
   else
   {
     eventPoint = posEvent->GetWorldPosition();
     mitk::BaseRenderer* sender = (mitk::BaseRenderer*) stateEvent->GetEvent()->GetSender();
-    eventPlaneNormal = sender->GetCurrentWorldGeometry2D()->GetAxisVector(2);
+    eventPlaneNormal = sender->GetCurrentWorldPlaneGeometry()->GetAxisVector(2);
   }
 
 
   bool ok = false;
   switch (action->GetActionId())
   {
   case mitk::AcNEWPOINT:
     {
       Press(eventPoint);
       ok = true;
       m_Started = true;
       break;
     }
   case mitk::AcINITMOVEMENT:
     {
       if (m_Started)
       {
         Move(eventPoint);
         ok = true;
         break;
       }
     }
   case mitk::AcMOVEPOINT:
     {
       if (m_Started)
       {
         Move(eventPoint);
         ok = true;
         break;
       }
     }
   case mitk::AcFINISHMOVEMENT:
     {
       if (m_Started)
       {
         mitk::ExtrudedContour* extrudedcontour = dynamic_cast<mitk::ExtrudedContour*>(m_DataNode->GetData());
         extrudedcontour->SetContour(m_Contour);
         extrudedcontour->SetVector(eventPlaneNormal);
         Release(eventPoint);
         ok = true;
         m_Started = false;
         InvokeEvent(itk::EndEvent());
       }
       break;
     }
   default:
     ok = false;
     break;
   }
   return ok;
 }
 
 void mitk::ExtrudedContourInteractor::Press(mitk::Point3D& point)
 {
   if (!m_Positive)
     m_ContourNode->SetColor(1.0,0.0,0.0);
 
   m_Contour->Initialize();
   m_Contour->AddVertex( point );
 }
 
 void mitk::ExtrudedContourInteractor::Move(mitk::Point3D& point)
 {
   assert(m_Contour.IsNotNull());
 
   m_Contour->AddVertex( point );
 //  m_Parent->UpdateWidgets();
 }
 
 void mitk::ExtrudedContourInteractor::Release(mitk::Point3D& /*point*/)
 {
 //vermutlich  m_Parent->UpdateWidgets();
 }
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index 4c72aa88dd..8fb489c2e3 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,666 +1,666 @@
 /*===================================================================
 
 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 <itkGradientMagnitudeImageFilter.h>
 
 #include <mitkBaseRenderer.h>
 #include <mitkContour.h>
 #include <mitkContourModelUtils.h>
 #include <mitkContourUtils.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkInteractionConst.h>
 #include <mitkRenderingManager.h>
 #include <mitkToolManager.h>
 
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include "mitkLiveWireTool2D.h"
 #include "mitkLiveWireTool2D.xpm"
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MitkSegmentation_EXPORT, LiveWireTool2D, "LiveWire tool");
 }
 
 static void AddInteractorToGlobalInteraction(mitk::Interactor* interactor)
 {
   mitk::GlobalInteraction::GetInstance()->AddInteractor(interactor);
 }
 
 static void RemoveInteractorFromGlobalInteraction(mitk::Interactor* interactor)
 {
   mitk::GlobalInteraction::GetInstance()->RemoveInteractor(interactor);
 }
 
 class RemoveFromDataStorage
 {
 public:
   RemoveFromDataStorage(mitk::DataStorage::Pointer dataStorage)
     : m_DataStorage(dataStorage)
   {
   }
 
   void operator()(mitk::DataNode* dataNode)
   {
     m_DataStorage->Remove(dataNode);
   }
 
   void operator()(const std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer>& dataNode)
   {
     m_DataStorage->Remove(dataNode.first);
   }
 
 private:
   mitk::DataStorage::Pointer m_DataStorage;
 };
 
 mitk::LiveWireTool2D::LiveWireTool2D()
   : SegTool2D("LiveWireTool")
 {
 }
 
 mitk::LiveWireTool2D::~LiveWireTool2D()
 {
   this->ClearSegmentation();
 }
 
 void mitk::LiveWireTool2D::RemoveHelperObjects()
 {
   DataStorage* dataStorage = m_ToolManager->GetDataStorage();
 
   if (!m_EditingContours.empty())
     std::for_each(m_EditingContours.begin(), m_EditingContours.end(), RemoveFromDataStorage(dataStorage));
 
   if (!m_WorkingContours.empty())
     std::for_each(m_WorkingContours.begin(), m_WorkingContours.end(), RemoveFromDataStorage(dataStorage));
 
   if (m_EditingContourNode.IsNotNull())
     dataStorage->Remove(m_EditingContourNode);
 
   if (m_LiveWireContourNode.IsNotNull())
     dataStorage->Remove(m_LiveWireContourNode);
 
   if (m_ContourModelNode.IsNotNull())
     dataStorage->Remove(m_ContourModelNode);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::LiveWireTool2D::ReleaseHelperObjects()
 {
   this->RemoveHelperObjects();
 
   if (!m_EditingContours.empty())
     m_EditingContours.clear();
 
   if (!m_WorkingContours.empty())
     m_WorkingContours.clear();
 
   m_EditingContourNode = NULL;
   m_EditingContour = NULL;
 
   m_LiveWireContourNode = NULL;
   m_LiveWireContour = NULL;
 
   m_ContourModelNode = NULL;
   m_Contour = NULL;
 }
 
 void mitk::LiveWireTool2D::ReleaseInteractors()
 {
   this->EnableContourLiveWireInteraction(false);
   m_LiveWireInteractors.clear();
 }
 
 void mitk::LiveWireTool2D::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("CheckContourClosed", OnCheckPoint);
 
   CONNECT_FUNCTION("InitObject", OnInitLiveWire);
   CONNECT_FUNCTION("AddPoint", OnAddPoint);
   CONNECT_FUNCTION("CtrlAddPoint", OnAddPoint);
   CONNECT_FUNCTION("MovePoint", OnMouseMoveNoDynamicCosts);
   CONNECT_FUNCTION("FinishContour", OnFinish);
   CONNECT_FUNCTION("DeletePoint", OnLastSegmentDelete);
   CONNECT_FUNCTION("CtrlMovePoint", OnMouseMoved);
 }
 
 const char** mitk::LiveWireTool2D::GetXPM() const
 {
   return mitkLiveWireTool2D_xpm;
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
 {
   return us::GetModuleContext()->GetModule()->GetResource("LiveWire_48x48.png");
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
 {
   return us::GetModuleContext()->GetModule()->GetResource("LiveWire_Cursor_32x32.png");
 }
 
 const char* mitk::LiveWireTool2D::GetName() const
 {
   return "Live Wire";
 }
 
 void mitk::LiveWireTool2D::Activated()
 {
   Superclass::Activated();
   this->ResetToStartState();
   this->EnableContourLiveWireInteraction(true);
 }
 
 void mitk::LiveWireTool2D::Deactivated()
 {
   Superclass::Deactivated();
   this->ConfirmSegmentation();
 }
 
 void mitk::LiveWireTool2D::EnableContourLiveWireInteraction(bool on)
 {
   std::for_each(m_LiveWireInteractors.begin(), m_LiveWireInteractors.end(), on
     ? AddInteractorToGlobalInteraction
     : RemoveInteractorFromGlobalInteraction);
 }
 
 void mitk::LiveWireTool2D::ConfirmSegmentation()
 {
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
 
   if (!workingNode)
     return;
 
   Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
 
   if (!workingImage)
     return;
 
   // for all contours in list (currently created by tool)
   std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator itWorkingContours = this->m_WorkingContours.begin();
   while(itWorkingContours != this->m_WorkingContours.end() )
   {
     // if node contains data
     if( itWorkingContours->first->GetData() )
     {
 
       // if this is a contourModel
       mitk::ContourModel* contourModel = dynamic_cast<mitk::ContourModel*>(itWorkingContours->first->GetData());
       if( contourModel )
       {
 
         // for each timestep of this contourModel
         for( TimeStepType currentTimestep = 0; currentTimestep < contourModel->GetTimeGeometry()->CountTimeSteps(); ++currentTimestep)
         {
 
           //get the segmentation image slice at current timestep
           mitk::Image::Pointer workingSlice = this->GetAffectedImageSliceAs2DImage(itWorkingContours->second, workingImage, currentTimestep);
 
           mitk::ContourModel::Pointer projectedContour = mitk::ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contourModel, true, false);
           mitk::ContourModelUtils::FillContourInSlice(projectedContour, workingSlice, 1.0);
 
           //write back to image volume
           this->WriteBackSegmentationResult(itWorkingContours->second, workingSlice, currentTimestep);
         }
       }
     }
 
     ++itWorkingContours;
   }
 
   this->ReleaseHelperObjects();
   this->ReleaseInteractors();
 }
 
 void mitk::LiveWireTool2D::ClearSegmentation()
 {
   this->ReleaseHelperObjects();
   this->ReleaseInteractors();
   this->ResetToStartState();
 }
 
 bool mitk::LiveWireTool2D::OnInitLiveWire ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
 
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   m_Contour = mitk::ContourModel::New();
   m_Contour->Expand(timestep+1);
   m_ContourModelNode = mitk::DataNode::New();
   m_ContourModelNode->SetData( m_Contour );
   m_ContourModelNode->SetName("working contour node");
   m_ContourModelNode->SetProperty( "layer", IntProperty::New(100));
   m_ContourModelNode->AddProperty( "fixedLayer", BoolProperty::New(true));
   m_ContourModelNode->SetProperty( "helper object", mitk::BoolProperty::New(true));
   m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1, 1, 0), NULL, true );
   m_ContourModelNode->AddProperty( "contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), NULL, true );
   m_ContourModelNode->AddProperty( "contour.controlpoints.show", BoolProperty::New(true), NULL, true );
 
   m_LiveWireContour = mitk::ContourModel::New();
   m_LiveWireContour->Expand(timestep+1);
   m_LiveWireContourNode = mitk::DataNode::New();
   m_LiveWireContourNode->SetData( m_LiveWireContour );
   m_LiveWireContourNode->SetName("active livewire node");
   m_LiveWireContourNode->SetProperty( "layer", IntProperty::New(101));
   m_LiveWireContourNode->AddProperty( "fixedLayer", BoolProperty::New(true));
   m_LiveWireContourNode->SetProperty( "helper object", mitk::BoolProperty::New(true));
   m_LiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
   m_LiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
 
   m_EditingContour = mitk::ContourModel::New();
   m_EditingContour->Expand(timestep+1);
   m_EditingContourNode = mitk::DataNode::New();
   m_EditingContourNode->SetData( m_EditingContour );
   m_EditingContourNode->SetName("editing node");
   m_EditingContourNode->SetProperty( "layer", IntProperty::New(102));
   m_EditingContourNode->AddProperty( "fixedLayer", BoolProperty::New(true));
   m_EditingContourNode->SetProperty( "helper object", mitk::BoolProperty::New(true));
   m_EditingContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
   m_EditingContourNode->AddProperty( "contour.points.color", ColorProperty::New(0.0, 0.0, 1.0), NULL, true );
   m_EditingContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
 
   mitk::DataNode* workingDataNode = m_ToolManager->GetWorkingData(0);
 
   m_ToolManager->GetDataStorage()->Add(m_ContourModelNode, workingDataNode);
   m_ToolManager->GetDataStorage()->Add(m_LiveWireContourNode, workingDataNode);
   m_ToolManager->GetDataStorage()->Add(m_EditingContourNode, workingDataNode);
 
   //set current slice as input for ImageToLiveWireContourFilter
   m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
 
   //Transfer LiveWire's center based contour output to corner based via the adaption of the input
   //slice image. Just in case someone stumbles across the 0.5 here I know what I'm doing ;-).
   m_WorkingSlice->GetSlicedGeometry()->ChangeImageGeometryConsideringOriginOffset(false);
   mitk::Point3D newOrigin = m_WorkingSlice->GetSlicedGeometry()->GetOrigin();
   m_WorkingSlice->GetSlicedGeometry()->WorldToIndex(newOrigin, newOrigin);
   newOrigin[2] += 0.5;
   m_WorkingSlice->GetSlicedGeometry()->IndexToWorld(newOrigin, newOrigin);
   m_WorkingSlice->GetSlicedGeometry()->SetOrigin(newOrigin);
 
 
   m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
   m_LiveWireFilter->SetInput(m_WorkingSlice);
 
   //map click to pixel coordinates
   mitk::Point3D click = positionEvent->GetPositionInWorld();
   itk::Index<3> idx;
   m_WorkingSlice->GetGeometry()->WorldToIndex(click, idx);
 
   // get the pixel the gradient in region of 5x5
   itk::Index<3> indexWithHighestGradient;
   AccessFixedDimensionByItk_2(m_WorkingSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
 
   // itk::Index to mitk::Point3D
   click[0] = indexWithHighestGradient[0];
   click[1] = indexWithHighestGradient[1];
   click[2] = indexWithHighestGradient[2];
   m_WorkingSlice->GetGeometry()->IndexToWorld(click, click);
 
   //set initial start point
   m_Contour->AddVertex( click, true, timestep );
   m_LiveWireFilter->SetStartPoint(click);
 
   m_CreateAndUseDynamicCosts = true;
 
   //render
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 
 bool mitk::LiveWireTool2D::OnAddPoint ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   //complete LiveWire interaction for last segment
   //add current LiveWire contour to the finished contour and reset
   //to start new segment and computation
 
   /* check if event can be handled */
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if (!positionEvent) return false;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   //add repulsive points to avoid to get the same path again
   typedef mitk::ImageLiveWireContourModelFilter::InternalImageType::IndexType IndexType;
   mitk::ContourModel::ConstVertexIterator iter = m_LiveWireContour->IteratorBegin(timestep);
   for (;iter != m_LiveWireContour->IteratorEnd(timestep); iter++)
   {
       IndexType idx;
       this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
 
       this->m_LiveWireFilter->AddRepulsivePoint( idx );
   }
 
   //remove duplicate first vertex, it's already contained in m_Contour
   m_LiveWireContour->RemoveVertexAt(0, timestep);
 
   // set last added point as control point
   m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices(timestep)-1, timestep);
 
   //merge contours
   m_Contour->Concatenate(m_LiveWireContour, timestep);
 
   //clear the livewire contour and reset the corresponding datanode
   m_LiveWireContour->Clear(timestep);
 
   //set new start point
   m_LiveWireFilter->SetStartPoint(positionEvent->GetPositionInWorld());
 
   if( m_CreateAndUseDynamicCosts )
   {
     //use dynamic cost map for next update
     m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
     m_LiveWireFilter->SetUseDynamicCostMap(true);
     //m_CreateAndUseDynamicCosts = false;
   }
 
   //render
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 bool mitk::LiveWireTool2D::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   //compute LiveWire segment from last control point to current mouse position
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if (!positionEvent) return false;
 
   // actual LiveWire computation
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   m_LiveWireFilter->SetEndPoint(positionEvent->GetPositionInWorld());
 
   m_LiveWireFilter->SetTimeStep( timestep );
   m_LiveWireFilter->Update();
 
   m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
   m_LiveWireContourNode->SetData( this->m_LiveWireContour );
 
   //render
   assert( positionEvent->GetSender()->GetRenderWindow() );
   positionEvent->GetSender()->GetRenderingManager()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 
 bool mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   //do not use dynamic cost map
   m_LiveWireFilter->SetUseDynamicCostMap(false);
   OnMouseMoved( NULL, interactionEvent);
   m_LiveWireFilter->SetUseDynamicCostMap(true);
   return true;
 }
 
 
 bool mitk::LiveWireTool2D::OnCheckPoint( const InteractionEvent* interactionEvent)
 {
   //check double click on first control point to finish the LiveWire tool
   //
   //Check distance to first point.
   //Transition YES if click close to first control point
   //
 
 
   const mitk::InteractionPositionEvent* positionEvent = dynamic_cast<const mitk::InteractionPositionEvent*>( interactionEvent );
   if (positionEvent)
   {
     int timestep = positionEvent->GetSender()->GetTimeStep();
 
     mitk::Point3D click = positionEvent->GetPositionInWorld();
     mitk::Point3D first = this->m_Contour->GetVertexAt(0, timestep)->Coordinates;
 
     if (first.EuclideanDistanceTo(click) < 4.5)
     {
       // allow to finish
       return true;
     }
     else
     {
       return false;
     }
   }
 
   return false;
 }
 
 
 bool mitk::LiveWireTool2D::OnFinish( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   // finish livewire tool interaction
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if (!positionEvent) return false;
 
   // actual timestep
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   // remove last control point being added by double click
   m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices(timestep) - 1, timestep);
 
   // save contour and corresponding plane geometry to list
-  std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> cp(m_ContourModelNode, dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldGeometry2D()->Clone().GetPointer()) );
+  std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> cp(m_ContourModelNode, dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone().GetPointer()) );
   this->m_WorkingContours.push_back(cp);
 
-  std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> ecp(m_EditingContourNode, dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldGeometry2D()->Clone().GetPointer()) );
+  std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> ecp(m_EditingContourNode, dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone().GetPointer()) );
   this->m_EditingContours.push_back(ecp);
 
   m_LiveWireFilter->SetUseDynamicCostMap(false);
 
   this->FinishTool();
 
   return true;
 }
 
 void mitk::LiveWireTool2D::FinishTool()
 {
   TimeStepType numberOfTimesteps = m_Contour->GetTimeGeometry()->CountTimeSteps();
 
   //close contour in each timestep
   for( int i = 0; i <= numberOfTimesteps; i++)
   {
     m_Contour->Close(i);
   }
 
   m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
 
   // clear live wire contour node
   m_LiveWireContourNode = NULL;
   m_LiveWireContour = NULL;
 
   //set the livewire interactor to edit control points
   m_ContourInteractor = mitk::ContourModelLiveWireInteractor::New(m_ContourModelNode);
   m_ContourInteractor->SetWorkingImage(this->m_WorkingSlice);
   m_ContourInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
   m_ContourModelNode->SetInteractor(m_ContourInteractor);
 
   this->m_LiveWireInteractors.push_back( m_ContourInteractor );
 
   //add interactor to globalInteraction instance
   mitk::GlobalInteraction::GetInstance()->AddInteractor(m_ContourInteractor);
 }
 
 
 bool mitk::LiveWireTool2D::OnLastSegmentDelete( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   int timestep = interactionEvent->GetSender()->GetTimeStep();
 
   //if last point of current contour will be removed go to start state and remove nodes
   if( m_Contour->GetNumberOfVertices(timestep) <= 1 )
   {
     m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
     m_ToolManager->GetDataStorage()->Remove( m_ContourModelNode );
     m_ToolManager->GetDataStorage()->Remove( m_EditingContourNode );
     m_LiveWireContour = mitk::ContourModel::New();
     m_Contour = mitk::ContourModel::New();
     m_ContourModelNode->SetData( m_Contour );
     m_LiveWireContourNode->SetData( m_LiveWireContour );
     this->ResetToStartState(); //go to start state
   }
   else //remove last segment from contour and reset livewire contour
   {
 
     m_LiveWireContour = mitk::ContourModel::New();
 
     m_LiveWireContourNode->SetData(m_LiveWireContour);
 
 
     mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
     newContour->Expand(m_Contour->GetTimeSteps());
 
     mitk::ContourModel::VertexIterator begin = m_Contour->IteratorBegin();
 
     //iterate from last point to next active point
     mitk::ContourModel::VertexIterator newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
 
     //go at least one down
     if(newLast != begin)
     {
       newLast--;
     }
 
     //search next active control point
     while(newLast != begin && !((*newLast)->IsControlPoint) )
     {
       newLast--;
     }
 
     //set position of start point for livewire filter to coordinates of the new last point
     m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
 
     mitk::ContourModel::VertexIterator it = m_Contour->IteratorBegin();
 
     //fill new Contour
     while(it <= newLast)
     {
       newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
       it++;
     }
 
     newContour->SetClosed(m_Contour->IsClosed());
 
     //set new contour visible
     m_ContourModelNode->SetData(newContour);
 
     m_Contour = newContour;
 
     assert( interactionEvent->GetSender()->GetRenderWindow() );
     mitk::RenderingManager::GetInstance()->RequestUpdate( interactionEvent->GetSender()->GetRenderWindow() );
   }
 
   return true;
 }
 
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension>* inputImage, itk::Index<3> &index, itk::Index<3> &returnIndex)
 {
   typedef itk::Image<TPixel, VImageDimension>  InputImageType;
   typedef typename InputImageType::IndexType            IndexType;
 
   unsigned long xMAX = inputImage->GetLargestPossibleRegion().GetSize()[0];
   unsigned long yMAX = inputImage->GetLargestPossibleRegion().GetSize()[1];
 
   returnIndex[0] = index[0];
   returnIndex[1] = index[1];
   returnIndex[2] = 0.0;
 
 
   double gradientMagnitude = 0.0;
   double maxGradientMagnitude = 0.0;
 
   /*
     the size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region
     not for searching the maximum value
     */
 
   //maximum value in each direction for size
   typename InputImageType::SizeType size;
   size[0] = 7;
   size[1] = 7;
 
   //minimum value in each direction for startRegion
   IndexType startRegion;
   startRegion[0] = index[0] - 3;
   startRegion[1] = index[1] - 3;
   if(startRegion[0] < 0) startRegion[0] = 0;
   if(startRegion[1] < 0) startRegion[1] = 0;
   if(xMAX - index[0] < 7) startRegion[0] = xMAX - 7;
   if(yMAX - index[1] < 7) startRegion[1] = yMAX - 7;
 
   index[0] = startRegion[0] + 3;
   index[1] = startRegion[1] + 3;
 
 
 
   typename InputImageType::RegionType region;
   region.SetSize( size );
   region.SetIndex( startRegion );
 
   typedef typename  itk::GradientMagnitudeImageFilter< InputImageType, InputImageType> GradientMagnitudeFilterType;
   typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
   gradientFilter->SetInput(inputImage);
   gradientFilter->GetOutput()->SetRequestedRegion(region);
 
   gradientFilter->Update();
   typename InputImageType::Pointer gradientMagnImage;
   gradientMagnImage = gradientFilter->GetOutput();
 
 
   IndexType currentIndex;
   currentIndex[0] = 0;
   currentIndex[1] = 0;
 
   // search max (approximate) gradient magnitude
   for( int x = -1; x <= 1; ++x)
   {
     currentIndex[0] = index[0] + x;
 
     for( int y = -1; y <= 1; ++y)
     {
       currentIndex[1] = index[1] + y;
 
       gradientMagnitude = gradientMagnImage->GetPixel(currentIndex);
 
       //check for new max
       if(maxGradientMagnitude < gradientMagnitude)
       {
         maxGradientMagnitude = gradientMagnitude;
         returnIndex[0] = currentIndex[0];
         returnIndex[1] = currentIndex[1];
         returnIndex[2] = 0.0;
       }//end if
     }//end for y
 
     currentIndex[1] = index[1];
   }//end for x
 
 }
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
index 761dae953c..f7b804cdf0 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
@@ -1,517 +1,517 @@
 /*===================================================================
 
 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 "mitkPaintbrushTool.h"
 
 #include "mitkToolManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkBaseRenderer.h"
 #include "mitkImageDataItem.h"
 #include "ipSegmentation.h"
 
 #include "mitkLevelWindowProperty.h"
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 int mitk::PaintbrushTool::m_Size = 1;
 
 mitk::PaintbrushTool::PaintbrushTool(int paintingPixelValue)
 :FeedbackContourTool("PressMoveReleaseWithCTRLInversionAllMouseMoves"),
  m_PaintingPixelValue(paintingPixelValue),
  m_LastContourSize(0) // other than initial mitk::PaintbrushTool::m_Size (around l. 28)
 {
   m_MasterContour = ContourModel::New();
   m_MasterContour->Initialize();
   m_CurrentPlane = NULL;
 
   m_WorkingNode = DataNode::New();
   m_WorkingNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0, 1) ) );
   m_WorkingNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
 }
 
 mitk::PaintbrushTool::~PaintbrushTool()
 {
 }
 
 void mitk::PaintbrushTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION( "PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION( "Move", OnPrimaryButtonPressedMoved);
   CONNECT_FUNCTION( "MouseMove", OnMouseMoved);
   CONNECT_FUNCTION( "Release", OnMouseReleased);
   CONNECT_FUNCTION( "InvertLogic", OnInvertLogic);
 }
 
 void mitk::PaintbrushTool::Activated()
 {
   Superclass::Activated();
   FeedbackContourTool::SetFeedbackContourVisible(true);
   SizeChanged.Send(m_Size);
   m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<mitk::PaintbrushTool>( this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified );
 }
 
 void mitk::PaintbrushTool::Deactivated()
 {
   FeedbackContourTool::SetFeedbackContourVisible(false);
   if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
       m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
   Superclass::Deactivated();
   m_WorkingSlice = NULL;
   m_CurrentPlane = NULL;
   m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<mitk::PaintbrushTool>( this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified );
 }
 
 void mitk::PaintbrushTool::SetSize(int value)
 {
   m_Size = value;
 }
 
 mitk::Point2D mitk::PaintbrushTool::upperLeft(mitk::Point2D p)
 {
    p[0] -= 0.5;
    p[1] += 0.5;
    return p;
 }
 
 
 void mitk::PaintbrushTool::UpdateContour(const InteractionPositionEvent* positionEvent)
 {
   //MITK_INFO<<"Update...";
   // examine stateEvent and create a contour that matches the pixel mask that we are going to draw
   //mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return;
 
   // Get Spacing of current Slice
-  //mitk::Vector3D vSpacing = m_WorkingSlice->GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing();
+  //mitk::Vector3D vSpacing = m_WorkingSlice->GetSlicedGeometry()->GetPlaneGeometry(0)->GetSpacing();
 
   //
   // Draw a contour in Square according to selected brush size
   //
   int radius = (m_Size)/2;
   float fradius = static_cast<float>(m_Size) / 2.0f;
 
   ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
 
 
   // estimate center point of the brush ( relative to the pixel the mouse points on )
   // -- left upper corner for even sizes,
   // -- midpoint for uneven sizes
   mitk::Point2D centerCorrection;
   centerCorrection.Fill(0);
 
   // even --> correction of [+0.5, +0.5]
   bool evenSize = ((m_Size % 2) == 0);
   if( evenSize )
   {
     centerCorrection[0] += 0.5;
     centerCorrection[1] += 0.5;
   }
 
   // we will compute the control points for the upper left quarter part of a circle contour
   std::vector< mitk::Point2D > quarterCycleUpperRight;
   std::vector< mitk::Point2D > quarterCycleLowerRight;
   std::vector< mitk::Point2D > quarterCycleLowerLeft;
   std::vector< mitk::Point2D > quarterCycleUpperLeft;
 
 
   mitk::Point2D curPoint;
   bool curPointIsInside = true;
   curPoint[0] = 0;
   curPoint[1] = radius;
   quarterCycleUpperRight.push_back( upperLeft(curPoint) );
 
   // to estimate if a pixel is inside the circle, we need to compare against the 'outer radius'
   // i.e. the distance from the midpoint [0,0] to the border of the pixel [0,radius]
   //const float outer_radius = static_cast<float>(radius) + 0.5;
 
   while (curPoint[1] > 0)
   {
      // Move right until pixel is outside circle
      float curPointX_squared = 0.0f;
      float curPointY_squared = (curPoint[1] - centerCorrection[1] ) * (curPoint[1] - centerCorrection[1] );
      while( curPointIsInside )
      {
         // increment posX and chec
         curPoint[0]++;
         curPointX_squared = (curPoint[0] - centerCorrection[0] ) * (curPoint[0] - centerCorrection[0] );
         const float len = sqrt( curPointX_squared + curPointY_squared);
         if ( len > fradius )
         {
            // found first Pixel in this horizontal line, that is outside the circle
            curPointIsInside = false;
         }
      }
      quarterCycleUpperRight.push_back( upperLeft(curPoint) );
 
      // Move down until pixel is inside circle
      while( !curPointIsInside )
      {
         // increment posX and chec
         curPoint[1]--;
         curPointY_squared = (curPoint[1] - centerCorrection[1] ) * (curPoint[1] - centerCorrection[1] );
         const float len = sqrt( curPointX_squared + curPointY_squared);
         if ( len <= fradius )
         {
            // found first Pixel in this horizontal line, that is outside the circle
            curPointIsInside = true;
            quarterCycleUpperRight.push_back( upperLeft(curPoint) );
         }
 
         // Quarter cycle is full, when curPoint y position is 0
         if (curPoint[1] <= 0)
            break;
      }
 
    }
 
   // QuarterCycle is full! Now copy quarter cycle to other quarters.
 
   if( !evenSize )
   {
     std::vector< mitk::Point2D >::const_iterator it = quarterCycleUpperRight.begin();
     while( it != quarterCycleUpperRight.end() )
     {
       mitk::Point2D p;
       p = *it;
 
       // the contour points in the lower right corner have same position but with negative y values
       p[1] *= -1;
       quarterCycleLowerRight.push_back(p);
 
       // the contour points in the lower left corner have same position
       // but with both x,y negative
       p[0] *= -1;
       quarterCycleLowerLeft.push_back(p);
 
       // the contour points in the upper left corner have same position
       // but with x negative
       p[1] *= -1;
       quarterCycleUpperLeft.push_back(p);
 
       it++;
     }
   }
   else
   {
     std::vector< mitk::Point2D >::const_iterator it = quarterCycleUpperRight.begin();
     while( it != quarterCycleUpperRight.end() )
     {
       mitk::Point2D p,q;
       p = *it;
 
       q = p;
       // the contour points in the lower right corner have same position but with negative y values
       q[1] *= -1;
       // correct for moved offset if size even = the midpoint is not the midpoint of the current pixel
       // but its upper rigt corner
       q[1] += 1;
       quarterCycleLowerRight.push_back(q);
 
       q = p;
       // the contour points in the lower left corner have same position
       // but with both x,y negative
       q[1] = -1.0f * q[1] + 1;
       q[0] = -1.0f * q[0] + 1;
       quarterCycleLowerLeft.push_back(q);
 
       // the contour points in the upper left corner have same position
       // but with x negative
       q = p;
       q[0] *= -1;
       q[0] +=  1;
       quarterCycleUpperLeft.push_back(q);
 
       it++;
     }
   }
 
   // fill contour with poins in right ordering, starting with the upperRight block
   mitk::Point3D tempPoint;
   for (unsigned int i=0; i<quarterCycleUpperRight.size(); i++)
   {
      tempPoint[0] = quarterCycleUpperRight[i][0];
      tempPoint[1] = quarterCycleUpperRight[i][1];
      tempPoint[2] = 0;
      contourInImageIndexCoordinates->AddVertex( tempPoint );
   }
   // the lower right has to be parsed in reverse order
   for (int i=quarterCycleLowerRight.size()-1; i>=0; i--)
   {
      tempPoint[0] = quarterCycleLowerRight[i][0];
      tempPoint[1] = quarterCycleLowerRight[i][1];
      tempPoint[2] = 0;
      contourInImageIndexCoordinates->AddVertex( tempPoint );
   }
   for (unsigned int i=0; i<quarterCycleLowerLeft.size(); i++)
   {
      tempPoint[0] = quarterCycleLowerLeft[i][0];
      tempPoint[1] = quarterCycleLowerLeft[i][1];
      tempPoint[2] = 0;
      contourInImageIndexCoordinates->AddVertex( tempPoint );
   }
   // the upper left also has to be parsed in reverse order
   for (int i=quarterCycleUpperLeft.size()-1; i>=0; i--)
   {
      tempPoint[0] = quarterCycleUpperLeft[i][0];
      tempPoint[1] = quarterCycleUpperLeft[i][1];
      tempPoint[2] = 0;
      contourInImageIndexCoordinates->AddVertex( tempPoint );
   }
 
   m_MasterContour = contourInImageIndexCoordinates;
 
 }
 
 
 /**
   Just show the contour, get one point as the central point and add surrounding points to the contour.
   */
 bool mitk::PaintbrushTool::OnMousePressed ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   m_MasterContour->SetClosed(true);
 
   return this->MouseMoved(interactionEvent, true);
 }
 
 bool mitk::PaintbrushTool::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
  return MouseMoved(interactionEvent, false);
 }
 
 bool mitk::PaintbrushTool::OnPrimaryButtonPressedMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
  return MouseMoved(interactionEvent, true);
 }
 
 /**
   Insert the point to the feedback contour,finish to build the contour and at the same time the painting function
   */
 bool mitk::PaintbrushTool::MouseMoved(mitk::InteractionEvent* interactionEvent, bool leftMouseButtonPressed)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
 
   CheckIfCurrentSliceHasChanged( positionEvent );
 
   if ( m_LastContourSize != m_Size )
   {
     UpdateContour( positionEvent );
     m_LastContourSize = m_Size;
   }
 
 //     stateEvent->GetId() == 530
 //     || stateEvent->GetId() == 534
 //     || stateEvent->GetId() == 1
 //     || stateEvent->GetId() == 5
 //     );
 
   Point3D worldCoordinates = positionEvent->GetPositionInWorld();
   Point3D indexCoordinates;
 
   m_WorkingSlice->GetGeometry()->WorldToIndex( worldCoordinates, indexCoordinates );
 
   MITK_DEBUG << "Mouse at W " << worldCoordinates << std::endl;
   MITK_DEBUG << "Mouse at I " << indexCoordinates << std::endl;
 
   // round to nearest voxel center (abort if this hasn't changed)
   if ( m_Size % 2 == 0 ) // even
   {
     indexCoordinates[0] = ROUND( indexCoordinates[0]);// /*+ 0.5*/) + 0.5;
     indexCoordinates[1] = ROUND( indexCoordinates[1]);// /*+ 0.5*/ ) + 0.5;
   }
   else // odd
   {
     indexCoordinates[0] = ROUND( indexCoordinates[0]  ) ;
     indexCoordinates[1] = ROUND( indexCoordinates[1] ) ;
   }
 
   static Point3D lastPos; // uninitialized: if somebody finds out how this can be initialized in a one-liner, tell me
   if ( fabs(indexCoordinates[0] - lastPos[0]) > mitk::eps ||
        fabs(indexCoordinates[1] - lastPos[1]) > mitk::eps ||
        fabs(indexCoordinates[2] - lastPos[2]) > mitk::eps ||
        leftMouseButtonPressed
      )
   {
     lastPos = indexCoordinates;
   }
   else
   {
     MITK_DEBUG << "." << std::flush;
     return false;
   }
 
   MITK_DEBUG << "Mouse at C " << indexCoordinates;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   ContourModel::Pointer contour = ContourModel::New();
   contour->Expand(timestep + 1);
   contour->SetClosed(true, timestep);
 
   ContourModel::VertexIterator it = m_MasterContour->Begin();
   ContourModel::VertexIterator end = m_MasterContour->End();
 
   while(it != end)
   {
     Point3D point = (*it)->Coordinates;
     point[0] += indexCoordinates[ 0 ];
     point[1] += indexCoordinates[ 1 ];
 
     contour->AddVertex( point, timestep );
     it++;
   }
 
 
   if (leftMouseButtonPressed)
   {
     FeedbackContourTool::FillContourInSlice( contour, timestep, m_WorkingSlice, m_PaintingPixelValue );
     m_WorkingNode->SetData(m_WorkingSlice);
     m_WorkingNode->Modified();
   }
 
   // visualize contour
   ContourModel::Pointer displayContour = ContourModel::New();
   displayContour->Initialize();
 
   //for (unsigned int index = 0; index < contour->GetNumberOfPoints(); ++index)
   //{
   //  Point3D point = contour->GetPoints()->ElementAt(index);
   //  if ( m_Size % 2 == 0 ) // even
   //  {
   //    point[0] += 0.5;
   //    point[1] += 0.5;
   //  }
   //  displayContour->AddVertex( point );
   //}
 
   displayContour = FeedbackContourTool::BackProjectContourFrom2DSlice( m_WorkingSlice->GetGeometry(), /*displayContour*/contour );
   SetFeedbackContour( *displayContour );
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
 
   RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 
 bool mitk::PaintbrushTool::OnMouseReleased( StateMachineAction*, InteractionEvent* interactionEvent )
 {
     //When mouse is released write segmentationresult back into image
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice->Clone());
 
   return true;
 }
 
 /**
   Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
   */
 bool mitk::PaintbrushTool::OnInvertLogic( StateMachineAction*, InteractionEvent* interactionEvent )
 {
     // Inversion only for 0 and 1 as painting values
     if (m_PaintingPixelValue == 1)
     {
       m_PaintingPixelValue = 0;
       FeedbackContourTool::SetFeedbackContourColor( 1.0, 0.0, 0.0 );
     }
     else if (m_PaintingPixelValue == 0)
     {
       m_PaintingPixelValue = 1;
       FeedbackContourTool::SetFeedbackContourColorDefault();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     return true;
 }
 
 void mitk::PaintbrushTool::CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event)
 {
-    const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (event->GetSender()->GetCurrentWorldGeometry2D() ) );
+    const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (event->GetSender()->GetCurrentWorldPlaneGeometry() ) );
     DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
 
     if (!workingNode)
         return;
 
     Image::Pointer image = dynamic_cast<Image*>(workingNode->GetData());
 
     if ( !image || !planeGeometry )
         return;
 
     if(m_CurrentPlane.IsNull() || m_WorkingSlice.IsNull())
     {
         m_CurrentPlane = const_cast<PlaneGeometry*>(planeGeometry);
         m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
         m_WorkingNode->ReplaceProperty( "color", workingNode->GetProperty("color") );
         m_WorkingNode->SetData(m_WorkingSlice);
     }
     else
     {
         bool isSameSlice (false);
         isSameSlice = mitk::MatrixEqualElementWise(planeGeometry->GetIndexToWorldTransform()->GetMatrix(),m_CurrentPlane->GetIndexToWorldTransform()->GetMatrix());
         isSameSlice = mitk::Equal(planeGeometry->GetIndexToWorldTransform()->GetOffset(),m_CurrentPlane->GetIndexToWorldTransform()->GetOffset());
         if (!isSameSlice)
         {
             m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
             m_CurrentPlane = NULL;
             m_WorkingSlice = NULL;
             m_WorkingNode = NULL;
             m_CurrentPlane = const_cast<PlaneGeometry*>(planeGeometry);
             m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
 
             m_WorkingNode = mitk::DataNode::New();
             m_WorkingNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0, 1) ) );
             m_WorkingNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
 
             m_WorkingNode->SetData(m_WorkingSlice);
 
             //So that the paintbrush contour vanished in the previous render window
             RenderingManager::GetInstance()->RequestUpdateAll();
         }
 
     }
 
     if(!m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
     {
 
         m_WorkingNode->SetProperty( "outline binary", mitk::BoolProperty::New(true) );
         m_WorkingNode->SetProperty( "color", workingNode->GetProperty("color") );
         m_WorkingNode->SetProperty( "name", mitk::StringProperty::New("Paintbrush_Node") );
         m_WorkingNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
         m_WorkingNode->SetProperty( "opacity", mitk::FloatProperty::New(0.8) );
         m_WorkingNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
         m_WorkingNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 
         m_ToolManager->GetDataStorage()->Add(m_WorkingNode);
     }
 }
 
 void mitk::PaintbrushTool::OnToolManagerWorkingDataModified()
 {
   //Here we simply set the current working slice to null. The next time the mouse is moved
   //within a renderwindow a new slice will be extracted from the new working data
   m_WorkingSlice = 0;
 }
diff --git a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
index 3397d71efe..a6f64920ed 100644
--- a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
@@ -1,702 +1,702 @@
 /*===================================================================
 
 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 "mitkRegionGrowingTool.h"
 #include "mitkToolManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 
 #include "mitkImageDataItem.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkApplicationCursor.h"
 
 #include "ipSegmentation.h"
 
 #include "mitkRegionGrowingTool.xpm"
 
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 #include "mitkExtractDirectedPlaneImageFilterNew.h"
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(MitkSegmentation_EXPORT, RegionGrowingTool, "Region growing tool");
 }
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 mitk::RegionGrowingTool::RegionGrowingTool()
 :FeedbackContourTool("PressMoveRelease"),
  m_LowerThreshold(200),
  m_UpperThreshold(200),
  m_InitialLowerThreshold(200),
  m_InitialUpperThreshold(200),
  m_ScreenYDifference(0),
  m_OriginalPicSlice(NULL),
  m_SeedPointMemoryOffset(0),
  m_VisibleWindow(0),
  m_DefaultWindow(0),
  m_MouseDistanceScaleFactor(0.5),
  m_LastWorkingSeed(-1),
  m_FillFeedbackContour(true)
 {
 }
 
 mitk::RegionGrowingTool::~RegionGrowingTool()
 {
 }
 
 void mitk::RegionGrowingTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION( "PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION( "Move", OnMouseMoved);
   CONNECT_FUNCTION( "Release", OnMouseReleased);
 }
 
 const char** mitk::RegionGrowingTool::GetXPM() const
 {
   return mitkRegionGrowingTool_xpm;
 }
 
 us::ModuleResource mitk::RegionGrowingTool::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::RegionGrowingTool::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("RegionGrowing_Cursor_32x32.png");
   return resource;
 }
 
 const char* mitk::RegionGrowingTool::GetName() const
 {
   return "Region Growing";
 }
 
 void mitk::RegionGrowingTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::RegionGrowingTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 /**
  1 Determine which slice is clicked into
  2 Determine if the user clicked inside or outside of the segmentation
  3 Depending on the pixel value under the mouse click position, two different things happen: (separated out into OnMousePressedInside and OnMousePressedOutside)
    3.1 Create a skeletonization of the segmentation and try to find a nice cut
      3.1.1 Call a ipSegmentation algorithm to create a nice cut
      3.1.2 Set the result of this algorithm as the feedback contour
    3.2 Initialize region growing
      3.2.1 Determine memory offset inside the original image
      3.2.2 Determine initial region growing parameters from the level window settings of the image
      3.2.3 Perform a region growing (which generates a new feedback contour)
  */
 bool mitk::RegionGrowingTool::OnMousePressed ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   //ToolLogger::SetVerboseness(3);
 
   MITK_DEBUG << "OnMousePressed" << std::endl;
   if ( FeedbackContourTool::CanHandleEvent(interactionEvent) > 0.0 )
   {
     MITK_DEBUG << "OnMousePressed: FeedbackContourTool says ok" << std::endl;
 
     // 1. Find out which slice the user clicked, find out which slice of the toolmanager's reference and working image corresponds to that
     if (positionEvent)
     {
       MITK_DEBUG << "OnMousePressed: got positionEvent" << std::endl;
 
       m_ReferenceSlice = FeedbackContourTool::GetAffectedReferenceSlice( positionEvent );
       m_WorkingSlice   = FeedbackContourTool::GetAffectedWorkingSlice( positionEvent );
 
       if ( m_WorkingSlice.IsNotNull() ) // can't do anything without the segmentation
       {
         MITK_DEBUG << "OnMousePressed: got working slice" << std::endl;
 
         // 2. Determine if the user clicked inside or outside of the segmentation
           const BaseGeometry* workingSliceGeometry = m_WorkingSlice->GetGeometry();
           Point3D mprojectedPointIn2D;
           workingSliceGeometry->WorldToIndex( positionEvent->GetPositionInWorld(), mprojectedPointIn2D);
           itk::Index<2> projectedPointInWorkingSlice2D;
           projectedPointInWorkingSlice2D[0] = static_cast<int>( mprojectedPointIn2D[0] - 0.5 );
           projectedPointInWorkingSlice2D[1] = static_cast<int>( mprojectedPointIn2D[1] - 0.5 );
 
           if ( workingSliceGeometry->IsIndexInside( projectedPointInWorkingSlice2D ) )
           {
             MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetPositionInWorld() << " (index coordinates " << projectedPointInWorkingSlice2D << ") IS in working slice" << std::endl;
 
             // Convert to ipMITKSegmentationTYPE (because getting pixels relys on that data type)
             itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
             CastToItkImage( m_WorkingSlice, correctPixelTypeImage );
             assert (correctPixelTypeImage.IsNotNull() );
 
           // possible bug in CastToItkImage ?
           // direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
           // mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
           // virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
           // solution here: we overwrite it with an unity matrix
           itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
           imageDirection.SetIdentity();
           correctPixelTypeImage->SetDirection(imageDirection);
 
           Image::Pointer temporarySlice = Image::New();
         //  temporarySlice = ImportItkImage( correctPixelTypeImage );
           CastToMitkImage( correctPixelTypeImage, temporarySlice );
 
           mitkIpPicDescriptor* workingPicSlice = mitkIpPicNew();
           CastToIpPicDescriptor(temporarySlice, workingPicSlice);
 
           int initialWorkingOffset = projectedPointInWorkingSlice2D[1] * workingPicSlice->n[0] + projectedPointInWorkingSlice2D[0];
 
           if ( initialWorkingOffset < static_cast<int>( workingPicSlice->n[0] * workingPicSlice->n[1] ) &&
                initialWorkingOffset >= 0 )
           {
             // 3. determine the pixel value under the last click
             bool inside = static_cast<ipMITKSegmentationTYPE*>(workingPicSlice->data)[initialWorkingOffset] != 0;
             m_PaintingPixelValue = inside ? 0 : 1; // if inside, we want to remove a part, otherwise we want to add something
 
             if ( m_LastWorkingSeed >= static_cast<int>( workingPicSlice->n[0] * workingPicSlice->n[1] ) ||
                  m_LastWorkingSeed < 0 )
             {
               inside = false;
             }
 
             if ( m_ReferenceSlice.IsNotNull() )
             {
               MITK_DEBUG << "OnMousePressed: got reference slice" << std::endl;
 
               m_OriginalPicSlice = mitkIpPicNew();
               CastToIpPicDescriptor(m_ReferenceSlice, m_OriginalPicSlice);
 
               // 3.1. Switch depending on the pixel value
               if (inside)
               {
                 OnMousePressedInside( NULL, interactionEvent, workingPicSlice, initialWorkingOffset);
               }
               else
               {
                 OnMousePressedOutside( NULL, interactionEvent);
               }
             }
           }
         }
       }
     }
   }
 
   MITK_DEBUG << "end OnMousePressed" << std::endl;
   return true;
 }
 
 /**
  3.1 Create a skeletonization of the segmentation and try to find a nice cut
    3.1.1 Call a ipSegmentation algorithm to create a nice cut
    3.1.2 Set the result of this algorithm as the feedback contour
 */
 bool mitk::RegionGrowingTool::OnMousePressedInside( StateMachineAction*, InteractionEvent* interactionEvent, mitkIpPicDescriptor* workingPicSlice, int initialWorkingOffset)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent()); // checked in OnMousePressed
   // 3.1.1. Create a skeletonization of the segmentation and try to find a nice cut
   // apply the skeletonization-and-cut algorithm
   // generate contour to remove
   // set m_ReferenceSlice = NULL so nothing will happen during mouse move
   // remember to fill the contour with 0 in mouserelease
   mitkIpPicDescriptor* segmentationHistory = ipMITKSegmentationCreateGrowerHistory( workingPicSlice, m_LastWorkingSeed, NULL ); // free again
   if (segmentationHistory)
   {
     tCutResult cutContour = ipMITKSegmentationGetCutPoints( workingPicSlice, segmentationHistory, initialWorkingOffset ); // tCutResult is a ipSegmentation type
     mitkIpPicFree( segmentationHistory );
     if (cutContour.cutIt)
     {
       int timestep = positionEvent->GetSender()->GetTimeStep();
       // 3.1.2 copy point from float* to mitk::Contour
       ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
       contourInImageIndexCoordinates->Expand(timestep + 1);
       contourInImageIndexCoordinates->SetClosed(true, timestep);
       Point3D newPoint;
       for (int index = 0; index < cutContour.deleteSize; ++index)
       {
         newPoint[0] = cutContour.deleteCurve[ 2 * index + 0 ] - 0.5;//correction is needed because the output of the algorithm is center based
         newPoint[1] = cutContour.deleteCurve[ 2 * index + 1 ] - 0.5;//and we want our contour displayed corner based.
         newPoint[2] = 0.0;
 
         contourInImageIndexCoordinates->AddVertex( newPoint, timestep );
       }
 
       free(cutContour.traceline);
       free(cutContour.deleteCurve); // perhaps visualize this for fun?
       free(cutContour.onGradient);
 
       ContourModel::Pointer contourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( m_WorkingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true: sub 0.5 for ipSegmentation correction
 
       FeedbackContourTool::SetFeedbackContour( *contourInWorldCoordinates );
       FeedbackContourTool::SetFeedbackContourVisible(true);
       mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
       m_FillFeedbackContour = true;
     }
     else
     {
       m_FillFeedbackContour = false;
     }
 
   }
   else
   {
     m_FillFeedbackContour = false;
   }
 
   m_ReferenceSlice = NULL;
 
   return true;
 }
 
 /**
  3.2 Initialize region growing
    3.2.1 Determine memory offset inside the original image
    3.2.2 Determine initial region growing parameters from the level window settings of the image
    3.2.3 Perform a region growing (which generates a new feedback contour)
 */
 bool mitk::RegionGrowingTool::OnMousePressedOutside( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent()); // checked in OnMousePressed
   // 3.2 If we have a reference image, then perform an initial region growing, considering the reference image's level window
 
   // if click was outside the image, don't continue
   const BaseGeometry* sliceGeometry = m_ReferenceSlice->GetGeometry();
   Point3D mprojectedPointIn2D;
   sliceGeometry->WorldToIndex( positionEvent->GetPositionInWorld(), mprojectedPointIn2D );
   itk::Index<2> projectedPointIn2D;
   projectedPointIn2D[0] = static_cast<int>( mprojectedPointIn2D[0] - 0.5 );
   projectedPointIn2D[1] = static_cast<int>( mprojectedPointIn2D[1] - 0.5 );
 
   if ( sliceGeometry->IsIndexInside( mprojectedPointIn2D ) )
   {
     MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetPositionInWorld() << " (index coordinates " << mprojectedPointIn2D << ") IS in reference slice" << std::endl;
 
     // 3.2.1 Remember Y cursor position and initial seed point
     //m_ScreenYPositionAtStart = static_cast<int>(positionEvent->GetDisplayPosition()[1]);
     m_LastScreenPosition = ApplicationCursor::GetInstance()->GetCursorPosition();
     m_ScreenYDifference = 0;
 
     m_SeedPointMemoryOffset = projectedPointIn2D[1] * m_OriginalPicSlice->n[0] + projectedPointIn2D[0];
     m_LastWorkingSeed = m_SeedPointMemoryOffset; // remember for skeletonization
 
     if ( m_SeedPointMemoryOffset < static_cast<int>( m_OriginalPicSlice->n[0] * m_OriginalPicSlice->n[1] ) &&
          m_SeedPointMemoryOffset >= 0 )
     {
 
       // 3.2.2 Get level window from reference DataNode
       //       Use some logic to determine initial gray value bounds
       LevelWindow lw(0, 500);
       m_ToolManager->GetReferenceData(0)->GetLevelWindow(lw); // will fill lw if levelwindow property is present, otherwise won't touch it.
 
       ScalarType currentVisibleWindow = lw.GetWindow();
 
       if (!mitk::Equal(currentVisibleWindow, m_VisibleWindow))
       {
         m_InitialLowerThreshold = currentVisibleWindow / 20.0;
         m_InitialUpperThreshold = currentVisibleWindow / 20.0;
         m_LowerThreshold = m_InitialLowerThreshold;
         m_UpperThreshold = m_InitialUpperThreshold;
 
         // 3.2.3. Actually perform region growing
         mitkIpPicDescriptor* result = PerformRegionGrowingAndUpdateContour(positionEvent->GetSender()->GetTimeStep());
         ipMITKSegmentationFree( result);
 
         // display the contour
         FeedbackContourTool::SetFeedbackContourVisible(true);
         mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 
         m_FillFeedbackContour = true;
       }
     }
 
   return true;
   }
 
   return false;
 }
 
 /**
  If in region growing mode (m_ReferenceSlice != NULL), then
  1. Calculate the new thresholds from mouse position (relative to first position)
  2. Perform a new region growing and update the feedback contour
 */
 bool mitk::RegionGrowingTool::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   if ( FeedbackContourTool::CanHandleEvent(interactionEvent) > 0.0 )
   {
     if ( m_ReferenceSlice.IsNotNull() && m_OriginalPicSlice )
     {
       mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
       //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
       if (positionEvent)
       {
         ApplicationCursor* cursor = ApplicationCursor::GetInstance();
         if (!cursor) return false;
         m_ScreenYDifference += cursor->GetCursorPosition()[1] - m_LastScreenPosition[1];
         cursor->SetCursorPosition( m_LastScreenPosition );
 
         m_LowerThreshold = std::max<mitk::ScalarType>(0.0, m_InitialLowerThreshold - m_ScreenYDifference * m_MouseDistanceScaleFactor);
         m_UpperThreshold = std::max<mitk::ScalarType>(0.0, m_InitialUpperThreshold - m_ScreenYDifference * m_MouseDistanceScaleFactor);
 
         // 2. Perform region growing again and show the result
         mitkIpPicDescriptor* result = PerformRegionGrowingAndUpdateContour(positionEvent->GetSender()->GetTimeStep());
         ipMITKSegmentationFree( result );
 
         // 3. Update the contour
         mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(positionEvent->GetSender()->GetRenderWindow());
       }
     }
   }
 
   return true;
 }
 
 /**
  If the feedback contour should be filled, then it is done here. (Contour is NOT filled, when skeletonization is done but no nice cut was found)
 */
 bool mitk::RegionGrowingTool::OnMouseReleased( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   if ( FeedbackContourTool::CanHandleEvent(interactionEvent) > 0.0 )
   {
     // 1. If we have a working slice, use the contour to fill a new piece on segmentation on it (or erase a piece that was selected by ipMITKSegmentationGetCutPoints)
     if ( m_WorkingSlice.IsNotNull() && m_OriginalPicSlice )
     {
       mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
       //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
       if (positionEvent)
       {
         // remember parameters for next time
         m_InitialLowerThreshold = m_LowerThreshold;
         m_InitialUpperThreshold = m_UpperThreshold;
 
         int timestep = positionEvent->GetSender()->GetTimeStep();
 
         if (m_FillFeedbackContour)
         {
           // 3. use contour to fill a region in our working slice
           ContourModel* feedbackContour( FeedbackContourTool::GetFeedbackContour() );
           if (feedbackContour)
           {
             ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice( m_WorkingSlice, feedbackContour, false, false ); // false: don't add any 0.5
                                                                                                                                     // false: don't constrain the contour to the image's inside
             if (projectedContour.IsNotNull())
             {
               FeedbackContourTool::FillContourInSlice( projectedContour, timestep, m_WorkingSlice, m_PaintingPixelValue );
 
-              const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+              const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
 
               //MITK_DEBUG << "OnMouseReleased: writing back to dimension " << affectedDimension << ", slice " << affectedSlice << " in working image" << std::endl;
 
              // 4. write working slice back into image volume
              this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice);
             }
           }
         }
 
         FeedbackContourTool::SetFeedbackContourVisible(false);
         mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
       }
     }
   }
 
   m_ReferenceSlice = NULL; // don't leak
   m_WorkingSlice = NULL;
   m_OriginalPicSlice = NULL;
 
   return true;
 }
 
 /**
 Uses ipSegmentation algorithms to do the actual region growing. The result (binary image) is first smoothed by a 5x5 circle mask, then
 its contour is extracted and converted to MITK coordinates.
 */
 mitkIpPicDescriptor* mitk::RegionGrowingTool::PerformRegionGrowingAndUpdateContour(int timestep)
 {
   // 1. m_OriginalPicSlice and m_SeedPointMemoryOffset are set to sensitive values, as well as m_LowerThreshold and m_UpperThreshold
   assert (m_OriginalPicSlice);
   if (m_OriginalPicSlice->n[0] != 256 || m_OriginalPicSlice->n[1] != 256) // ???
   assert( (m_SeedPointMemoryOffset < static_cast<int>( m_OriginalPicSlice->n[0] * m_OriginalPicSlice->n[1] )) && (m_SeedPointMemoryOffset >= 0) ); // inside the image
 
   // 2. ipSegmentation is used to perform region growing
   float ignored;
   int oneContourOffset( 0 );
   mitkIpPicDescriptor* regionGrowerResult = ipMITKSegmentationGrowRegion4N( m_OriginalPicSlice,
                                                                         m_SeedPointMemoryOffset,       // seed point
                                                                         true,              // grayvalue interval relative to seed point gray value?
                                                                         m_LowerThreshold,
                                                                         m_UpperThreshold,
                                                                         0,                  // continue until done (maxIterations == 0)
                                                                         NULL,               // allocate new memory (only this time, on mouse move we'll reuse the old buffer)
                                                                         oneContourOffset,   // a pixel that is near the resulting contour
                                                                         ignored             // ignored by us
                                                                       );
 
   if (!regionGrowerResult || oneContourOffset == -1)
   {
     ContourModel::Pointer dummyContour = ContourModel::New();
     dummyContour->Initialize();
     FeedbackContourTool::SetFeedbackContour( *dummyContour );
 
     if (regionGrowerResult) ipMITKSegmentationFree(regionGrowerResult);
     return NULL;
   }
 
   // 3. We smooth the result a little to reduce contour complexity
   bool smoothResult( true ); // currently fixed, perhaps remove else block
   mitkIpPicDescriptor* smoothedRegionGrowerResult;
   if (smoothResult)
   {
     // Smooth the result (otherwise very detailed contour)
     smoothedRegionGrowerResult = SmoothIPPicBinaryImage( regionGrowerResult, oneContourOffset );
 
     ipMITKSegmentationFree( regionGrowerResult );
   }
   else
   {
     smoothedRegionGrowerResult = regionGrowerResult;
   }
 
   // 4. convert the result of region growing into a mitk::Contour
   // At this point oneContourOffset could be useless, if smoothing destroyed a thin bridge. In these
   // cases, we have two or more unconnected segmentation regions, and we don't know, which one is touched by oneContourOffset.
   // In the bad case, the contour is not the one around our seedpoint, so the result looks very strange to the user.
   // -> we remove the point where the contour started so far. Then we look from the bottom of the image for the first segmentation pixel
   //    and start another contour extraction from there. This is done, until the seedpoint is inside the contour
   int numberOfContourPoints( 0 );
   int newBufferSize( 0 );
   float* contourPoints = ipMITKSegmentationGetContour8N( smoothedRegionGrowerResult, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
   if (contourPoints)
   {
     while ( !ipMITKSegmentationIsInsideContour( contourPoints,                                               // contour
                                                 numberOfContourPoints,                                       // points in contour
                                                 m_SeedPointMemoryOffset % smoothedRegionGrowerResult->n[0],  // test point x
                                                 m_SeedPointMemoryOffset / smoothedRegionGrowerResult->n[0]   // test point y
                                               ) )
     {
       // we decide that this cannot be part of the segmentation because the seedpoint is not contained in the contour (fill the 4-neighborhood with 0)
       ipMITKSegmentationReplaceRegion4N( smoothedRegionGrowerResult, oneContourOffset, 0 );
 
       // move the contour offset to the last row (x position of the seed point)
       int rowLength = smoothedRegionGrowerResult->n[0]; // number of pixels in a row
       oneContourOffset =    m_SeedPointMemoryOffset % smoothedRegionGrowerResult->n[0]  // x of seed point
                           + rowLength*(smoothedRegionGrowerResult->n[1]-1);              // y of last row
 
       while (    oneContourOffset >=0
               && (*(static_cast<ipMITKSegmentationTYPE*>(smoothedRegionGrowerResult->data) + oneContourOffset) == 0) )
       {
         oneContourOffset -= rowLength; // if pixel at data+oneContourOffset is 0, then move up one row
       }
 
       if ( oneContourOffset < 0 )
       {
         break; // just use the last contour we found
       }
 
       free(contourPoints); // release contour memory
       contourPoints = ipMITKSegmentationGetContour8N( smoothedRegionGrowerResult, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
     }
 
     // copy point from float* to mitk::Contour
     ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
     contourInImageIndexCoordinates->Expand(timestep + 1);
     contourInImageIndexCoordinates->SetClosed(true, timestep);
     Point3D newPoint;
     for (int index = 0; index < numberOfContourPoints; ++index)
     {
       newPoint[0] = contourPoints[ 2 * index + 0 ] - 0.5;//correction is needed because the output of the algorithm is center based
       newPoint[1] = contourPoints[ 2 * index + 1 ] - 0.5;//and we want our contour displayed corner based.
       newPoint[2] = 0;
 
       contourInImageIndexCoordinates->AddVertex( newPoint, timestep );
     }
 
     free(contourPoints);
 
     ContourModel::Pointer contourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( m_ReferenceSlice->GetGeometry(), contourInImageIndexCoordinates, true );   // true: sub 0.5 for ipSegmentation correctio
 
     FeedbackContourTool::SetFeedbackContour( *contourInWorldCoordinates );
   }
 
   // 5. Result HAS TO BE freed by caller, contains the binary region growing result
   return smoothedRegionGrowerResult;
 }
 
 /**
   Helper method for SmoothIPPicBinaryImage. Smoothes a given part of and image.
 
   \param sourceImage The original binary image.
   \param dest The smoothed image (will be written without bounds checking).
   \param contourOfs One offset of the contour. Is updated if a pixel is changed (which might change the contour).
   \param maskOffsets Memory offsets that describe the smoothing mask.
   \param maskSize Entries of the mask.
   \param startOffset First pixel that should be smoothed using this mask.
   \param endOffset Last pixel that should be smoothed using this mask.
 */
 void mitk::RegionGrowingTool::SmoothIPPicBinaryImageHelperForRows( mitkIpPicDescriptor* sourceImage, mitkIpPicDescriptor* dest, int &contourOfs, int* maskOffsets, int maskSize, int startOffset, int endOffset )
 {
   // work on the very first row
   ipMITKSegmentationTYPE* current;
   ipMITKSegmentationTYPE* source = ((ipMITKSegmentationTYPE*)sourceImage->data) + startOffset; // + 1! don't read at start-1
   ipMITKSegmentationTYPE* end = ((ipMITKSegmentationTYPE*)dest->data) + endOffset;
   int ofs = startOffset;
   int minority = (maskSize - 1) / 2;
 
   for (current = ((ipMITKSegmentationTYPE*)dest->data) + startOffset; current<end; current++)
   {
     mitkIpInt1_t sum( 0 );
     for (int i = 0; i < maskSize; ++i)
     {
       sum += *(source+maskOffsets[i]);
     }
 
     if (sum > minority)
     {
       *current = 1;
       contourOfs = ofs;
     }
     else
     {
       *current = 0;
     }
 
     ++source;
     ++ofs;
   }
 }
 
 /**
 Smoothes a binary ipPic image with a 5x5 mask. The image borders (some first and last rows) are treated differently.
 */
 mitkIpPicDescriptor* mitk::RegionGrowingTool::SmoothIPPicBinaryImage( mitkIpPicDescriptor* image, int &contourOfs, mitkIpPicDescriptor* dest )
 {
   if (!image) return NULL;
 
   // Original code from /trunk/mbi-qm/Qmitk/Qmitk2DSegTools/RegionGrowerTool.cpp (first version by T. Boettger?). Reformatted and documented and restructured.
   #define MSK_SIZE5x5 21
   #define MSK_SIZE3x3 5
   #define MSK_SIZE3x1 3
 
   // mask is an array of coordinates that form a rastered circle like this
   //
   //            OOO
   //           OOOOO
   //           OOOOO
   //           OOOOO
   //            OOO
   //
   //
   int mask5x5[MSK_SIZE5x5][2]
   = {
   /******/ {-1,-2}, {0,-2}, {1,-2}, /*****/
   {-2,-1}, {-1,-1}, {0,-1}, {1,-1}, {2,-1},
   {-2, 0}, {-1, 0}, {0, 0}, {1, 0}, {2, 0},
   {-2, 1}, {-1, 1}, {0, 1}, {1, 1}, {2, 1},
   /******/ {-1, 2}, {0, 2}, {1, 2}  /*****/
   };
 
   int mask3x3[MSK_SIZE3x3][2]
   = {
   /******/ {0,-1}, /*****/
   {-1, 0}, {0, 0}, {1, 0},
   /******/ {0, 1} /*****/
   };
 
   int mask3x1[MSK_SIZE3x1][2]
   = {
   {-1, 0}, {0, 0}, {1, 0}
   };
 
 
   // The following lines iterate over all the pixels of a (sliced) image (except the first and last three rows).
   // For each pixel, all the coordinates around it (according to mask) are evaluated (this means 21 pixels).
   // If more than 10 of the evaluated pixels are non-zero, then the central pixel is set to 1, else to 0.
   // This is determining a majority. If there is no clear majority, then the central pixel itself "decides".
   int maskOffset5x5[MSK_SIZE5x5];
   int line = image->n[0];
   for (int i=0; i<MSK_SIZE5x5; i++)
   {
     maskOffset5x5[i] = mask5x5[i][0] + line * mask5x5[i][1]; // calculate memory offsets from the x,y mask elements
   }
 
   int maskOffset3x3[MSK_SIZE3x3];
   for (int i=0; i<MSK_SIZE3x3; i++)
   {
     maskOffset3x3[i] = mask3x3[i][0] + line * mask3x3[i][1]; // calculate memory offsets from the x,y mask elements
   }
 
   int maskOffset3x1[MSK_SIZE3x1];
   for (int i=0; i<MSK_SIZE3x1; i++)
   {
     maskOffset3x1[i] = mask3x1[i][0] + line * mask3x1[i][1]; // calculate memory offsets from the x,y mask elements
   }
 
 
   if (!dest)
   {
     // create pic if necessary
     dest = ipMITKSegmentationNew( image );
   }
 
   int spareOut3Rows = 3*image->n[0];
   int spareOut1Rows = 1*image->n[0];
 
   if ( image->n[1] > 0 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x1, MSK_SIZE3x1, 1, dest->n[0] );
   if ( image->n[1] > 3 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x3, MSK_SIZE3x3, spareOut1Rows, dest->n[0]*3 );
   if ( image->n[1] > 6 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset5x5, MSK_SIZE5x5, spareOut3Rows, dest->n[0]*dest->n[1] - spareOut3Rows );
   if ( image->n[1] > 8 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x3, MSK_SIZE3x3, dest->n[0]*dest->n[1] -spareOut3Rows, dest->n[0]*dest->n[1] - spareOut1Rows );
   if ( image->n[1] > 10) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x1, MSK_SIZE3x1, dest->n[0]*dest->n[1] -spareOut1Rows, dest->n[0]*dest->n[1] - 1 );
 
   // correction for first pixel (sorry for the ugliness)
   if ( *((ipMITKSegmentationTYPE*)(dest->data)+1) == 1 )
   {
     *((ipMITKSegmentationTYPE*)(dest->data)+0) = 1;
   }
 
   if (dest->n[0] * dest->n[1] > 2)
   {
     // correction for last pixel
     if ( *((ipMITKSegmentationTYPE*)(dest->data)+dest->n[0]*dest->n[1]-2) == 1 )
     {
       *((ipMITKSegmentationTYPE*)(dest->data)+dest->n[0]*dest->n[1]-1) = 1;
     }
   }
 
   return dest;
 }
 
 
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 51dcba5d8f..4c3b383549 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,407 +1,407 @@
 /*===================================================================
 
 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 "mitkSegTool2D.h"
 #include "mitkToolManager.h"
 
 #include "mitkDataStorage.h"
 #include "mitkBaseRenderer.h"
 
 #include "mitkPlaneGeometry.h"
 
 #include "mitkExtractImageFilter.h"
 #include "mitkExtractDirectedPlaneImageFilter.h"
 
 //Include of the new ImageExtractor
 #include "mitkExtractDirectedPlaneImageFilterNew.h"
 #include "mitkPlanarCircle.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 
 #include "usGetModuleContext.h"
 
 //Includes for 3DSurfaceInterpolation
 #include "mitkImageToContourFilter.h"
 #include "mitkSurfaceInterpolationController.h"
 
 //includes for resling and overwriting
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <vtkSmartPointer.h>
 #include <vtkImageData.h>
 
 #include <mitkDiffSliceOperationApplier.h>
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 mitk::SegTool2D::SegTool2D(const char* type)
 :Tool(type),
 m_LastEventSender(NULL),
 m_LastEventSlice(0),
 m_Contourmarkername ("Position"),
 m_ShowMarkerNodes (false),
 m_3DInterpolationEnabled(true)
 {
 }
 
 mitk::SegTool2D::~SegTool2D()
 {
 }
 
 float mitk::SegTool2D::CanHandleEvent( InteractionEvent const *stateEvent) const
 {
   const InteractionPositionEvent* positionEvent = dynamic_cast<const InteractionPositionEvent*>( stateEvent );
   if (!positionEvent) return 0.0;
 
   if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D )
     return 0.0; // we don't want anything but 2D
 
   return 1.0;
 
 //   //This are the mouse event that are used by the statemachine patterns for zooming and panning. This must be possible although a tool is activ
 //   if (stateEvent->GetId() == EIDRIGHTMOUSEBTN || stateEvent->GetId() == EIDMIDDLEMOUSEBTN || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDCTRL ||
 //     stateEvent->GetId() == EIDMIDDLEMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDMOUSEMOVE ||
 //     stateEvent->GetId() == EIDMIDDLEMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNRELEASE )
 //   {
 //     //Since the usual segmentation tools currently do not need right click interaction but the mitkDisplayVectorInteractor
 //     return 0.0;
 //   }
 //   else
 //   {
 //     return 1.0;
 //   }
 
 }
 
 
 
 bool mitk::SegTool2D::DetermineAffectedImageSlice( const Image* image, const PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   Vector3D normal       = plane->GetNormal();
   Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.SetVnlVector( vnl_cross_3d<ScalarType>(normal.GetVnlVector(),imageNormal0.GetVnlVector()) );
   imageNormal1.SetVnlVector( vnl_cross_3d<ScalarType>(normal.GetVnlVector(),imageNormal1.GetVnlVector()) );
   imageNormal2.SetVnlVector( vnl_cross_3d<ScalarType>(normal.GetVnlVector(),imageNormal2.GetVnlVector()) );
 
   double eps( 0.00001 );
   // axial
   if ( imageNormal2.GetNorm() <= eps )
   {
     affectedDimension = 2;
   }
   // sagittal
   else if ( imageNormal1.GetNorm() <= eps )
   {
     affectedDimension = 1;
   }
   // frontal
   else if ( imageNormal0.GetNorm() <= eps )
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   BaseGeometry* imageGeometry = image->GetGeometry(0);
   Point3D testPoint = imageGeometry->GetCenter();
   Point3D projectedPoint;
   plane->Project( testPoint, projectedPoint );
 
   Point3D indexPoint;
 
   imageGeometry->WorldToIndex( projectedPoint, indexPoint );
   affectedSlice = ROUND( indexPoint[affectedDimension] );
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice " << affectedSlice;
 
   // check if this index is still within the image
   if ( affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)) ) return false;
 
   return true;
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent* positionEvent, const Image* image)
 {
   if (!positionEvent) return NULL;
 
   assert( positionEvent->GetSender() ); // sure, right?
   unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image ); // get the timestep of the visible part (time-wise) of the image
 
   // first, we determine, which slice is affected
-  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
 
   return this->GetAffectedImageSliceAs2DImage(planeGeometry, image, timeStep);
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry* planeGeometry, const Image* image, unsigned int timeStep)
 {
   if ( !image || !planeGeometry ) return NULL;
 
   //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   //set to false to extract a slice
   reslice->SetOverwriteMode(false);
   reslice->Modified();
 
   //use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
   mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput( image );
   extractor->SetTimeStep( timeStep );
   extractor->SetWorldGeometry( planeGeometry );
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry( image->GetTimeGeometry()->GetGeometryForTimeStep( timeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   Image::Pointer slice = extractor->GetOutput();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the non edited slice
   m_undoOperation = new DiffSliceOperation(const_cast<mitk::Image*>(image), extractor->GetVtkOutput(), dynamic_cast<SlicedGeometry3D*>(slice->GetGeometry()), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   /*============= END undo feature block ========================*/
 
   return slice;
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent* positionEvent)
 {
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if ( !workingNode ) return NULL;
 
   Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
   if ( !workingImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, workingImage );
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent* positionEvent)
 {
   DataNode* referenceNode( m_ToolManager->GetReferenceData(0) );
   if ( !referenceNode ) return NULL;
 
   Image* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
   if ( !referenceImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, referenceImage );
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult (const InteractionPositionEvent* positionEvent, Image* slice)
 {
   if(!positionEvent) return;
 
-  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
 
   if( planeGeometry && slice)
   {
     DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
     Image* image = dynamic_cast<Image*>(workingNode->GetData());
     unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image );
     this->WriteBackSegmentationResult(planeGeometry, slice, timeStep);
 
     slice->DisconnectPipeline();
     ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
     contourExtractor->SetInput(slice);
     contourExtractor->Update();
     mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
     if (m_3DInterpolationEnabled && contour->GetVtkPolyData()->GetNumberOfPoints() > 0 && image->GetDimension() == 3)
     {
       unsigned int pos = this->AddContourmarker(positionEvent);
       us::ServiceReference<PlanePositionManagerService> serviceRef =
           us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
       PlanePositionManagerService* service = us::GetModuleContext()->GetService(serviceRef);
       mitk::SurfaceInterpolationController::GetInstance()->AddNewContour( contour, service->GetPlanePosition(pos));
       contour->DisconnectPipeline();
     }
   }
 
 }
 
 
 void mitk::SegTool2D::WriteBackSegmentationResult (const PlaneGeometry* planeGeometry, Image* slice, unsigned int timeStep)
 {
   if(!planeGeometry || !slice) return;
 
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
 
 
   //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   //Set the slice as 'input'
   reslice->SetInputSlice(slice->GetVtkImageData());
 
   //set overwrite mode to true to write back to the image volume
   reslice->SetOverwriteMode(true);
   reslice->Modified();
 
   mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput( image );
   extractor->SetTimeStep( timeStep );
   extractor->SetWorldGeometry( planeGeometry );
   extractor->SetVtkOutputRequest(true);
   extractor->SetResliceTransformByGeometry( image->GetGeometry( timeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   //the image was modified within the pipeline, but not marked so
   image->Modified();
   image->GetVtkImageData()->Modified();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the edited slice
   m_doOperation = new DiffSliceOperation(image, extractor->GetVtkOutput(),dynamic_cast<SlicedGeometry3D*>(slice->GetGeometry()), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
 
   //create an operation event for the undo stack
   OperationEvent* undoStackItem = new OperationEvent( DiffSliceOperationApplier::GetInstance(), m_doOperation, m_undoOperation, "Segmentation" );
 
   //add it to the undo controller
   UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
 
   //clear the pointers as the operation are stored in the undocontroller and also deleted from there
   m_undoOperation = NULL;
   m_doOperation = NULL;
   /*============= END undo feature block ========================*/
 
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
 }
 
 void mitk::SegTool2D::SetShowMarkerNodes(bool status)
 {
   m_ShowMarkerNodes = status;
 }
 
 void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
 {
   m_3DInterpolationEnabled = enabled;
 }
 
 unsigned int mitk::SegTool2D::AddContourmarker ( const InteractionPositionEvent* positionEvent )
 {
   const mitk::PlaneGeometry* plane = dynamic_cast<const PlaneGeometry*> (dynamic_cast< const mitk::SlicedGeometry3D*>(
-    positionEvent->GetSender()->GetSliceNavigationController()->GetCurrentGeometry3D())->GetGeometry2D(0));
+    positionEvent->GetSender()->GetSliceNavigationController()->GetCurrentGeometry3D())->GetPlaneGeometry(0));
 
   us::ServiceReference<PlanePositionManagerService> serviceRef =
       us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
   PlanePositionManagerService* service = us::GetModuleContext()->GetService(serviceRef);
   unsigned int size = service->GetNumberOfPlanePositions();
   unsigned int id = service->AddNewPlanePosition(plane, positionEvent->GetSender()->GetSliceNavigationController()->GetSlice()->GetPos());
 
   mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
   mitk::Point2D p1;
   plane->Map(plane->GetCenter(), p1);
   mitk::Point2D p2 = p1;
   p2[0] -= plane->GetSpacing()[0];
   p2[1] -= plane->GetSpacing()[1];
   contourMarker->PlaceFigure( p1 );
   contourMarker->SetCurrentControlPoint( p1 );
-  contourMarker->SetGeometry2D( const_cast<PlaneGeometry*>(plane));
+  contourMarker->SetPlaneGeometry( const_cast<PlaneGeometry*>(plane));
 
   std::stringstream markerStream;
   mitk::DataNode* workingNode (m_ToolManager->GetWorkingData(0));
 
   markerStream << m_Contourmarkername ;
   markerStream << " ";
   markerStream << id+1;
 
   DataNode::Pointer rotatedContourNode = DataNode::New();
 
   rotatedContourNode->SetData(contourMarker);
   rotatedContourNode->SetProperty( "name", StringProperty::New(markerStream.str()) );
   rotatedContourNode->SetProperty( "isContourMarker", BoolProperty::New(true));
   rotatedContourNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, positionEvent->GetSender() );
   rotatedContourNode->SetProperty( "includeInBoundingBox", BoolProperty::New(false));
   rotatedContourNode->SetProperty( "helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
   rotatedContourNode->SetProperty( "planarfigure.drawcontrolpoints", BoolProperty::New(false));
   rotatedContourNode->SetProperty( "planarfigure.drawname", BoolProperty::New(false));
   rotatedContourNode->SetProperty( "planarfigure.drawoutline", BoolProperty::New(false));
   rotatedContourNode->SetProperty( "planarfigure.drawshadow", BoolProperty::New(false));
 
   if (plane)
   {
 
     if ( id ==  size )
     {
       m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
     else
     {
       mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
 
       mitk::DataStorage::SetOfObjects::ConstPointer markers = m_ToolManager->GetDataStorage()->GetDerivations(workingNode,isMarker);
 
       for ( mitk::DataStorage::SetOfObjects::const_iterator iter = markers->begin();
         iter != markers->end();
         ++iter)
       {
         std::string nodeName = (*iter)->GetName();
         unsigned int t = nodeName.find_last_of(" ");
         unsigned int markerId = atof(nodeName.substr(t+1).c_str())-1;
         if(id == markerId)
         {
           return id;
         }
       }
       m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
   }
   return id;
 }
 
 void mitk::SegTool2D::InteractiveSegmentationBugMessage( const std::string& message )
 {
   MITK_ERROR << "********************************************************************************" << std::endl
     << " " << message << std::endl
     << "********************************************************************************" << std::endl
     << "  " << std::endl
     << " If your image is rotated or the 2D views don't really contain the patient image, try to press the button next to the image selection. " << std::endl
     << "  " << std::endl
     << " Please file a BUG REPORT: " << std::endl
     << " http://bugs.mitk.org" << std::endl
     << " Contain the following information:" << std::endl
     << "  - What image were you working on?" << std::endl
     << "  - Which region of the image?" << std::endl
     << "  - Which tool did you use?" << std::endl
     << "  - What did you do?" << std::endl
     << "  - What happened (not)? What did you expect?" << std::endl;
 }
diff --git a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
index 5a5fec1b95..9a83a7d1f1 100644
--- a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
@@ -1,330 +1,330 @@
 /*===================================================================
 
 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 "mitkSetRegionTool.h"
 
 #include "mitkToolManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 
 #include "ipSegmentation.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkImageDataItem.h"
 #include "mitkLegacyAdaptors.h"
 
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 
 mitk::SetRegionTool::SetRegionTool(int paintingPixelValue)
 :FeedbackContourTool("PressMoveReleaseWithCTRLInversion"),
  m_PaintingPixelValue(paintingPixelValue),
  m_FillContour(false),
  m_StatusFillWholeSlice(false)
 {
 }
 
 mitk::SetRegionTool::~SetRegionTool()
 {
 }
 
 void mitk::SetRegionTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION( "PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION( "Release", OnMouseReleased);
   CONNECT_FUNCTION( "InvertLogic", OnInvertLogic);
 }
 
 void mitk::SetRegionTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::SetRegionTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 bool mitk::SetRegionTool::OnMousePressed ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
   int timeStep = positionEvent->GetSender()->GetTimeStep();
 
   if ( FeedbackContourTool::CanHandleEvent(interactionEvent) < 1.0 ) return false;
 
 
   // 1. Get the working image
   Image::Pointer workingSlice   = FeedbackContourTool::GetAffectedWorkingSlice( positionEvent );
   if ( workingSlice.IsNull() ) return false; // can't do anything without the segmentation
 
   // if click was outside the image, don't continue
   const BaseGeometry* sliceGeometry = workingSlice->GetGeometry();
   itk::Index<2> projectedPointIn2D;
   sliceGeometry->WorldToIndex( positionEvent->GetPositionInWorld(), projectedPointIn2D );
   if ( !sliceGeometry->IsIndexInside( projectedPointIn2D ) )
   {
     MITK_ERROR << "point apparently not inside segmentation slice" << std::endl;
     return false; // can't use that as a seed point
   }
 
     // Convert to ipMITKSegmentationTYPE (because ipMITKSegmentationGetContour8N relys on that data type)
     itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
     CastToItkImage( workingSlice, correctPixelTypeImage );
     assert (correctPixelTypeImage.IsNotNull() );
 
   // possible bug in CastToItkImage ?
   // direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
   // mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
   // virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
   // solution here: we overwrite it with an unity matrix
   itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
   imageDirection.SetIdentity();
   correctPixelTypeImage->SetDirection(imageDirection);
 
     Image::Pointer temporarySlice = Image::New();
   //  temporarySlice = ImportItkImage( correctPixelTypeImage );
     CastToMitkImage( correctPixelTypeImage, temporarySlice );
 
 
   // check index positions
   mitkIpPicDescriptor* originalPicSlice = mitkIpPicNew();
   CastToIpPicDescriptor( temporarySlice, originalPicSlice );
 
   int m_SeedPointMemoryOffset = projectedPointIn2D[1] * originalPicSlice->n[0] + projectedPointIn2D[0];
 
   if ( m_SeedPointMemoryOffset >= static_cast<int>( originalPicSlice->n[0] * originalPicSlice->n[1] ) ||
        m_SeedPointMemoryOffset < 0 )
   {
     MITK_ERROR << "Memory offset calculation if mitk::SetRegionTool has some serious flaw! Aborting.." << std::endl;
     return false;
   }
 
   // 2. Determine the contour that surronds the selected "piece of the image"
 
   // find a contour seed point
   unsigned int oneContourOffset = static_cast<unsigned int>( m_SeedPointMemoryOffset ); // safe because of earlier check if m_SeedPointMemoryOffset < 0
 
   /**
     * The logic of finding a starting point for the contour is the following:
     *
     *  - If the initial seed point is 0, we are either inside a hole or outside of every segmentation.
     *    We move to the right until we hit a 1, which must be part of a contour.
     *
     *  - If the initial seed point is 1, then ...
     *    we now do the same (running to the right) until we hit a 1
     *
     *  In both cases the found contour point is used to extract a contour and
     *  then a test is applied to find out if the initial seed point is contained
     *  in the contour. If this is the case, filling should be applied, otherwise
     *  nothing is done.
     */
   unsigned int size = originalPicSlice->n[0] * originalPicSlice->n[1];
 /*
   unsigned int rowSize = originalPicSlice->n[0];
 */
   ipMITKSegmentationTYPE* data = static_cast<ipMITKSegmentationTYPE*>(originalPicSlice->data);
 
   if ( data[oneContourOffset] == 0 ) // initial seed 0
   {
     for ( ; oneContourOffset < size; ++oneContourOffset )
     {
       if ( data[oneContourOffset] > 0 ) break;
     }
   }
   else if ( data[oneContourOffset] == 1 ) // initial seed 1
   {
     unsigned int lastValidPixel = size-1; // initialization, will be changed lateron
     bool inSeg = true;    // inside segmentation?
     for ( ; oneContourOffset < size; ++oneContourOffset )
     {
       if ( ( data[oneContourOffset] == 0 ) && inSeg ) // pixel 0 and inside-flag set: this happens at the first pixel outside a filled region
       {
         inSeg = false;
         lastValidPixel = oneContourOffset - 1; // store the last pixel position inside a filled region
         break;
       }
       else // pixel 1, inside-flag doesn't matter: this happens while we are inside a filled region
       {
         inSeg = true; // first iteration lands here
       }
 
     }
     oneContourOffset = lastValidPixel;
   }
   else
   {
     MITK_ERROR << "Fill/Erase was never intended to work with other than binary images." << std::endl;
     m_FillContour = false;
     return false;
   }
 
   if (oneContourOffset == size) // nothing found until end of slice
   {
     m_FillContour = false;
     return false;
   }
 
   int numberOfContourPoints( 0 );
   int newBufferSize( 0 );
   //MITK_INFO << "getting contour from offset " << oneContourOffset << " ("<<oneContourOffset%originalPicSlice->n[0]<<","<<oneContourOffset/originalPicSlice->n[0]<<")"<<std::endl;
   float* contourPoints = ipMITKSegmentationGetContour8N( originalPicSlice, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
 
   //MITK_INFO << "contourPoints " << contourPoints << " (N="<<numberOfContourPoints<<")"<<std::endl;
   assert(contourPoints == NULL || numberOfContourPoints > 0);
 
   bool cursorInsideContour = ipMITKSegmentationIsInsideContour( contourPoints, numberOfContourPoints, projectedPointIn2D[0], projectedPointIn2D[1]);
 
   // decide if contour should be filled or not
   m_FillContour = cursorInsideContour;
 
   if (m_FillContour)
   {
     // copy point from float* to mitk::Contour
     ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
     contourInImageIndexCoordinates->Expand(timeStep + 1);
     contourInImageIndexCoordinates->SetClosed(true, timeStep);
     Point3D newPoint;
     for (int index = 0; index < numberOfContourPoints; ++index)
     {
       newPoint[0] = contourPoints[ 2 * index + 0 ] - 0.5;
       newPoint[1] = contourPoints[ 2 * index + 1] - 0.5;
       newPoint[2] = 0;
 
       contourInImageIndexCoordinates->AddVertex(newPoint, timeStep);
     }
 
     m_SegmentationContourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( workingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true, correct the result from ipMITKSegmentationGetContour8N
 
     // 3. Show the contour
     FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
 
     FeedbackContourTool::SetFeedbackContourVisible(true);
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
 
   // always generate a second contour, containing the whole image (used when CTRL is pressed)
   {
     // copy point from float* to mitk::Contour
     ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
     contourInImageIndexCoordinates->Expand(timeStep + 1);
     contourInImageIndexCoordinates->SetClosed(true, timeStep);
     Point3D newPoint;
     newPoint[0] = 0; newPoint[1] = 0; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
     newPoint[0] = originalPicSlice->n[0]; newPoint[1] = 0; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
     newPoint[0] = originalPicSlice->n[0]; newPoint[1] = originalPicSlice->n[1]; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
     newPoint[0] = 0; newPoint[1] = originalPicSlice->n[1]; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
 
     m_WholeImageContourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( workingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true, correct the result from ipMITKSegmentationGetContour8N
 
     // 3. Show the contour
     FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
 
     FeedbackContourTool::SetFeedbackContourVisible(true);
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
 
 
   free(contourPoints);
 
   return true;
 }
 
 bool mitk::SetRegionTool::OnMouseReleased( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   // 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's working image corresponds to that
   FeedbackContourTool::SetFeedbackContourVisible(false);
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 
   int timeStep = positionEvent->GetSender()->GetTimeStep();
 
   if (!m_FillContour && !m_StatusFillWholeSlice) return true;
 
   if ( FeedbackContourTool::CanHandleEvent(interactionEvent) < 1.0 ) return false;
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if (!workingNode) return false;
 
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
-  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+  const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
   if ( !image || !planeGeometry ) return false;
 
   Image::Pointer slice = FeedbackContourTool::GetAffectedImageSliceAs2DImage( positionEvent, image );
 
   if ( slice.IsNull() )
   {
       MITK_ERROR << "Unable to extract slice." << std::endl;
       return false;
   }
 
   ContourModel* feedbackContour( FeedbackContourTool::GetFeedbackContour() );
   ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice( slice, feedbackContour, false, false ); // false: don't add 0.5 (done by FillContourInSlice)
   // false: don't constrain the contour to the image's inside
   if (projectedContour.IsNull()) return false;
 
   FeedbackContourTool::FillContourInSlice( projectedContour, timeStep, slice, m_PaintingPixelValue );
 
   this->WriteBackSegmentationResult(positionEvent, slice);
 
   m_WholeImageContourInWorldCoordinates = NULL;
   m_SegmentationContourInWorldCoordinates = NULL;
 
   return true;
 }
 
 /**
   Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
 */
 bool mitk::SetRegionTool::OnInvertLogic( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   if ( FeedbackContourTool::CanHandleEvent(interactionEvent) < 1.0 ) return false;
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   if (m_StatusFillWholeSlice)
   {
     // use contour extracted from image data
     if (m_SegmentationContourInWorldCoordinates.IsNotNull())
       FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
   else
   {
     // use some artificial contour
     if (m_WholeImageContourInWorldCoordinates.IsNotNull())
       FeedbackContourTool::SetFeedbackContour( *m_WholeImageContourInWorldCoordinates );
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
 
   m_StatusFillWholeSlice = !m_StatusFillWholeSlice;
 
   return true;
 }
 
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
index 449d5a2e2f..b5a06fd874 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
@@ -1,1090 +1,1090 @@
 /*===================================================================
 
 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 "QmitkSlicesInterpolator.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkSelectableGLWidget.h"
 
 #include "mitkToolManager.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkProgressBar.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkInteractionConst.h"
 #include "mitkApplyDiffImageOperation.h"
 #include "mitkDiffImageApplier.h"
 #include "mitkSegTool2D.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkSurfaceToImageFilter.h"
 #include "mitkSliceNavigationController.h"
 #include <mitkVtkImageOverwrite.h>
 #include <mitkExtractSliceFilter.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkImageWriteAccessor.h>
 
 #include <itkCommand.h>
 
 #include <QCheckBox>
 #include <QPushButton>
 #include <QMenu>
 #include <QCursor>
 #include <QVBoxLayout>
 #include <QMessageBox>
 
 
 //#define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 const std::map<QAction*, mitk::SliceNavigationController*> QmitkSlicesInterpolator::createActionToSliceDimension()
 {
   std::map<QAction*, mitk::SliceNavigationController*> actionToSliceDimension;
   foreach(mitk::SliceNavigationController* slicer, m_ControllerToDeleteObserverTag.keys())
   {
     actionToSliceDimension[new QAction(QString::fromStdString(slicer->GetViewDirectionAsString()),0)] = slicer;
   }
 
   return actionToSliceDimension;
 }
 
 
 QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget* parent, const char*  /*name*/)
   :QWidget(parent),
 //    ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
     m_Interpolator( mitk::SegmentationInterpolationController::New() ),
     m_SurfaceInterpolator(mitk::SurfaceInterpolationController::GetInstance()),
     m_ToolManager(NULL),
     m_Initialized(false),
     m_LastSNC(0),
     m_LastSliceIndex(0),
     m_2DInterpolationEnabled(false),
     m_3DInterpolationEnabled(false)
 {
   m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
 
 
 
   QVBoxLayout* vboxLayout = new QVBoxLayout(m_GroupBoxEnableExclusiveInterpolationMode);
 
   m_CmbInterpolation = new QComboBox(m_GroupBoxEnableExclusiveInterpolationMode);
   m_CmbInterpolation->addItem("Disabled");
   m_CmbInterpolation->addItem("2-Dimensional");
   m_CmbInterpolation->addItem("3-Dimensional");
   vboxLayout->addWidget(m_CmbInterpolation);
 
   m_BtnApply2D = new QPushButton("Confirm for single slice", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApply2D);
 
   m_BtnApplyForAllSlices2D = new QPushButton("Confirm for all slices", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApplyForAllSlices2D);
 
   m_BtnApply3D = new QPushButton("Confirm", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApply3D);
 
   m_ChkShowPositionNodes = new QCheckBox("Show Position Nodes", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_ChkShowPositionNodes);
 
   this->HideAllInterpolationControls();
 
   connect(m_CmbInterpolation, SIGNAL(currentIndexChanged(int)), this, SLOT(OnInterpolationMethodChanged(int)));
   connect(m_BtnApply2D, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()));
   connect(m_BtnApplyForAllSlices2D, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()));
   connect(m_BtnApply3D, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
   connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
   connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
 
   QHBoxLayout* layout = new QHBoxLayout(this);
   layout->addWidget(m_GroupBoxEnableExclusiveInterpolationMode);
   this->setLayout(layout);
 
   itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
   command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged );
   InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver( itk::ModifiedEvent(), command );
 
   itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
   command2->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged );
   SurfaceInterpolationInfoChangedObserverTag = m_SurfaceInterpolator->AddObserver( itk::ModifiedEvent(), command2 );
 
   // feedback node and its visualization properties
   m_FeedbackNode = mitk::DataNode::New();
   mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties( m_FeedbackNode );
 
   m_FeedbackNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
   m_FeedbackNode->SetProperty( "outline binary", mitk::BoolProperty::New(true) );
   m_FeedbackNode->SetProperty( "color", mitk::ColorProperty::New(255.0, 255.0, 0.0) );
   m_FeedbackNode->SetProperty( "texture interpolation", mitk::BoolProperty::New(false) );
   m_FeedbackNode->SetProperty( "layer", mitk::IntProperty::New( 20 ) );
   m_FeedbackNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0, 1) ) );
   m_FeedbackNode->SetProperty( "name", mitk::StringProperty::New("Interpolation feedback") );
   m_FeedbackNode->SetProperty( "opacity", mitk::FloatProperty::New(0.8) );
   m_FeedbackNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
 
   m_InterpolatedSurfaceNode = mitk::DataNode::New();
   m_InterpolatedSurfaceNode->SetProperty( "color", mitk::ColorProperty::New(255.0,255.0,0.0) );
   m_InterpolatedSurfaceNode->SetProperty( "name", mitk::StringProperty::New("Surface Interpolation feedback") );
   m_InterpolatedSurfaceNode->SetProperty( "opacity", mitk::FloatProperty::New(0.5) );
   m_InterpolatedSurfaceNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
   m_InterpolatedSurfaceNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
   m_InterpolatedSurfaceNode->SetVisibility(false);
 
   m_3DContourNode = mitk::DataNode::New();
   m_3DContourNode->SetProperty( "color", mitk::ColorProperty::New(0.0, 0.0, 0.0) );
   m_3DContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_3DContourNode->SetProperty( "name", mitk::StringProperty::New("Drawn Contours") );
   m_3DContourNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
   m_3DContourNode->SetProperty("material.wireframeLineWidth", mitk::FloatProperty::New(2.0f));
   m_3DContourNode->SetProperty("3DContourContainer", mitk::BoolProperty::New(true));
   m_3DContourNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 
   QWidget::setContentsMargins(0, 0, 0, 0);
   if ( QWidget::layout() != NULL )
   {
     QWidget::layout()->setContentsMargins(0, 0, 0, 0);
   }
 
   //For running 3D Interpolation in background
   // create a QFuture and a QFutureWatcher
 
   connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(OnSurfaceInterpolationFinished()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
   m_Timer = new QTimer(this);
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
 }
 
 void QmitkSlicesInterpolator::SetDataStorage( mitk::DataStorage::Pointer storage )
 {
   m_DataStorage = storage;
   m_SurfaceInterpolator->SetDataStorage(storage);
 }
 
 mitk::DataStorage* QmitkSlicesInterpolator::GetDataStorage()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 
 void QmitkSlicesInterpolator::Initialize(mitk::ToolManager* toolManager, const QList<mitk::SliceNavigationController *> &controllers)
 {
   Q_ASSERT(!controllers.empty());
 
   if (m_Initialized)
   {
     // remove old observers
     Uninitialize();
   }
 
   m_ToolManager = toolManager;
 
   if (m_ToolManager)
   {
     // set enabled only if a segmentation is selected
     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
     QWidget::setEnabled( node != NULL );
 
     // react whenever the set of selected segmentation changes
     m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
     m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
 
     // connect to the slice navigation controller. after each change, call the interpolator
     foreach(mitk::SliceNavigationController* slicer, controllers)
     {
       //Has to be initialized
       m_LastSNC = slicer;
       m_TimeStep.insert(slicer, slicer->GetTime()->GetPos());
 
       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer deleteCommand = itk::MemberCommand<QmitkSlicesInterpolator>::New();
       deleteCommand->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted);
       m_ControllerToDeleteObserverTag.insert(slicer, slicer->AddObserver(itk::DeleteEvent(), deleteCommand));
 
       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer timeChangedCommand = itk::MemberCommand<QmitkSlicesInterpolator>::New();
       timeChangedCommand->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnTimeChanged);
       m_ControllerToTimeObserverTag.insert(slicer, slicer->AddObserver(mitk::SliceNavigationController::TimeGeometryEvent(NULL,0), timeChangedCommand));
 
       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer sliceChangedCommand = itk::MemberCommand<QmitkSlicesInterpolator>::New();
       sliceChangedCommand->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSliceChanged);
       m_ControllerToSliceObserverTag.insert(slicer, slicer->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(NULL,0), sliceChangedCommand));
     }
     ACTION_TO_SLICEDIMENSION = createActionToSliceDimension();
   }
 
   m_Initialized = true;
 }
 
 void QmitkSlicesInterpolator::Uninitialize()
 {
   if (m_ToolManager.IsNotNull())
   {
     m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified);
     m_ToolManager->ReferenceDataChanged -= mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified);
   }
 
   foreach(mitk::SliceNavigationController* slicer, m_ControllerToSliceObserverTag.keys())
   {
     slicer->RemoveObserver(m_ControllerToDeleteObserverTag.take(slicer));
     slicer->RemoveObserver(m_ControllerToTimeObserverTag.take(slicer));
     slicer->RemoveObserver(m_ControllerToSliceObserverTag.take(slicer));
   }
 
   ACTION_TO_SLICEDIMENSION.clear();
 
   m_ToolManager = NULL;
 
   m_Initialized = false;
 }
 
 QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
 {
   if (m_Initialized)
   {
     // remove old observers
     Uninitialize();
   }
 
   if(m_DataStorage->Exists(m_3DContourNode))
     m_DataStorage->Remove(m_3DContourNode);
   if(m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     m_DataStorage->Remove(m_InterpolatedSurfaceNode);
 
   // remove observer
   m_Interpolator->RemoveObserver( InterpolationInfoChangedObserverTag );
   m_SurfaceInterpolator->RemoveObserver( SurfaceInterpolationInfoChangedObserverTag );
 
   delete m_Timer;
 }
 
 /**
 External enableization...
 */
 void QmitkSlicesInterpolator::setEnabled( bool enable )
 {
   QWidget::setEnabled(enable);
 
   //Set the gui elements of the different interpolation modi enabled
   if (enable)
   {
     if (m_2DInterpolationEnabled)
     {
       this->Show2DInterpolationControls(true);
       m_Interpolator->Activate2DInterpolation(true);
     }
     else if (m_3DInterpolationEnabled)
     {
       this->Show3DInterpolationControls(true);
       this->Show3DInterpolationResult(true);
     }
   }
   //Set all gui elements of the interpolation disabled
   else
   {
     this->HideAllInterpolationControls();
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
 {
   OnInterpolationActivated(status);
   m_Interpolator->Activate2DInterpolation(status);
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
 {
   On3DInterpolationActivated(status);
 }
 
 void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
 {
   if (status)
   {
     OnInterpolationActivated(!status);
     On3DInterpolationActivated(!status);
     this->Show3DInterpolationResult(false);
   }
 }
 
 
 
 void QmitkSlicesInterpolator::HideAllInterpolationControls()
 {
   this->Show2DInterpolationControls(false);
   this->Show3DInterpolationControls(false);
 }
 
 void QmitkSlicesInterpolator::Show2DInterpolationControls(bool show)
 {
   m_BtnApply2D->setVisible(show);
   m_BtnApplyForAllSlices2D->setVisible(show);
 }
 
 void QmitkSlicesInterpolator::Show3DInterpolationControls(bool show)
 {
   m_BtnApply3D->setVisible(show);
   m_ChkShowPositionNodes->setVisible(show);
 }
 
 
 
 void QmitkSlicesInterpolator::OnInterpolationMethodChanged(int index)
 {
   switch(index)
   {
     case 0: // Disabled
       m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation");
       this->HideAllInterpolationControls();
       this->OnInterpolationActivated(false);
       this->On3DInterpolationActivated(false);
       this->Show3DInterpolationResult(false);
       m_Interpolator->Activate2DInterpolation(false);
       break;
 
     case 1: // 2D
       m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
       this->HideAllInterpolationControls();
       this->Show2DInterpolationControls(true);
       this->OnInterpolationActivated(true);
       this->On3DInterpolationActivated(false);
       m_Interpolator->Activate2DInterpolation(true);
       break;
 
     case 2: // 3D
       m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
       this->HideAllInterpolationControls();
       this->Show3DInterpolationControls(true);
       this->OnInterpolationActivated(false);
       this->On3DInterpolationActivated(true);
       m_Interpolator->Activate2DInterpolation(false);
       break;
 
     default:
       MITK_ERROR << "Unknown interpolation method!";
       m_CmbInterpolation->setCurrentIndex(0);
       break;
   }
 }
 
 void QmitkSlicesInterpolator::OnShowMarkers(bool state)
 {
   mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker"
                                                                                                                               , mitk::BoolProperty::New(true)));
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
   {
     it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
   }
 }
 
 void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
 {
   if (m_ToolManager->GetWorkingData(0) != 0)
   {
     m_Segmentation = dynamic_cast<mitk::Image*>(m_ToolManager->GetWorkingData(0)->GetData());
   }
   else
   {
     //If no workingdata is set, remove the interpolation feedback
     this->GetDataStorage()->Remove(m_FeedbackNode);
     m_FeedbackNode->SetData(NULL);
     this->GetDataStorage()->Remove(m_3DContourNode);
     m_3DContourNode->SetData(NULL);
     this->GetDataStorage()->Remove(m_InterpolatedSurfaceNode);
     m_InterpolatedSurfaceNode->SetData(NULL);
     return;
   }
   //Updating the current selected segmentation for the 3D interpolation
   SetCurrentContourListID();
 
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated( true ); // re-initialize if needed
   }
   this->CheckSupportedImageDimension();
 }
 
 void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
 {
 }
 
 void QmitkSlicesInterpolator::OnTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   //Check if we really have a GeometryTimeEvent
   if (!dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent*>(&e))
     return;
 
   mitk::SliceNavigationController* slicer = dynamic_cast<mitk::SliceNavigationController*>(sender);
   Q_ASSERT(slicer);
 
   m_TimeStep[slicer]/* = event.GetPos()*/;
 
   //TODO Macht das hier wirklich Sinn????
   if (m_LastSNC == slicer)
   {
     slicer->SendSlice();//will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
 {
   //Check whether we really have a GeometrySliceEvent
   if (!dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent*>(&e))
     return;
 
   mitk::SliceNavigationController* slicer = dynamic_cast<mitk::SliceNavigationController*>(sender);
 
   if (TranslateAndInterpolateChangedSlice(e, slicer))
   {
     slicer->GetRenderer()->RequestUpdate();
   }
 }
 
 bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject& e, mitk::SliceNavigationController* slicer)
 {
   if (!m_2DInterpolationEnabled) return false;
 
   try
   {
     const mitk::SliceNavigationController::GeometrySliceEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent&>(e);
 
     mitk::TimeGeometry* tsg = event.GetTimeGeometry();
     if (tsg && m_TimeStep.contains(slicer))
     {
       mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(tsg->GetGeometryForTimeStep(m_TimeStep[slicer]).GetPointer());
       if (slicedGeometry)
       {
         m_LastSNC = slicer;
-        mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( event.GetPos() ));
+        mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetPlaneGeometry( event.GetPos() ));
         if (plane)
           Interpolate( plane, m_TimeStep[slicer], slicer );
         return true;
       }
     }
   }
   catch(std::bad_cast)
   {
     return false; // so what
   }
 
   return false;
 }
 
 void QmitkSlicesInterpolator::Interpolate( mitk::PlaneGeometry* plane, unsigned int timeStep, mitk::SliceNavigationController* slicer )
 {
   if (m_ToolManager)
   {
     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
     if (node)
     {
       m_Segmentation = dynamic_cast<mitk::Image*>(node->GetData());
       if (m_Segmentation)
       {
         int clickedSliceDimension(-1);
         int clickedSliceIndex(-1);
 
         // calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
         mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex );
 
         mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( clickedSliceDimension, clickedSliceIndex, plane, timeStep );
         m_FeedbackNode->SetData( interpolation );
 
         m_LastSNC = slicer;
         m_LastSliceIndex = clickedSliceIndex;
       }
     }
   }
 }
 
 void QmitkSlicesInterpolator::OnSurfaceInterpolationFinished()
 {
   mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult();
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
 
   if(interpolatedSurface.IsNotNull() && workingNode &&
      workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3"))))
   {
     m_BtnApply3D->setEnabled(true);
     m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
     m_3DContourNode->SetData(m_SurfaceInterpolator->GetContoursAsSurface());
 
     this->Show3DInterpolationResult(true);
 
     if( !m_DataStorage->Exists(m_InterpolatedSurfaceNode) && !m_DataStorage->Exists(m_3DContourNode))
     {
       m_DataStorage->Add(m_3DContourNode);
       m_DataStorage->Add(m_InterpolatedSurfaceNode);
     }
   }
   else if (interpolatedSurface.IsNull())
   {
     m_BtnApply3D->setEnabled(false);
 
     if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     {
       this->Show3DInterpolationResult(false);
     }
   }
 
   foreach (mitk::SliceNavigationController* slicer, m_ControllerToTimeObserverTag.keys())
   {
     slicer->GetRenderer()->RequestUpdate();
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
 {
   if (m_Segmentation && m_FeedbackNode->GetData())
   {
     //making interpolation separately undoable
     mitk::UndoStackItem::IncCurrObjectEventId();
     mitk::UndoStackItem::IncCurrGroupEventId();
     mitk::UndoStackItem::ExecuteIncrement();
 
     //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
     vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
     // Set slice as input
     mitk::Image::Pointer slice = dynamic_cast<mitk::Image*>(m_FeedbackNode->GetData());
     reslice->SetInputSlice(slice->GetSliceData()->GetVtkImageData(slice));
     //set overwrite mode to true to write back to the image volume
     reslice->SetOverwriteMode(true);
     reslice->Modified();
 
     mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
     extractor->SetInput( m_Segmentation );
     unsigned int timestep = m_LastSNC->GetTime()->GetPos();
     extractor->SetTimeStep( timestep );
     extractor->SetWorldGeometry( m_LastSNC->GetCurrentPlaneGeometry() );
     extractor->SetVtkOutputRequest(true);
     extractor->SetResliceTransformByGeometry( m_Segmentation->GetTimeGeometry()->GetGeometryForTimeStep( timestep ) );
 
     extractor->Modified();
     extractor->Update();
 
     //the image was modified within the pipeline, but not marked so
     m_Segmentation->Modified();
     m_Segmentation->GetVtkImageData()->Modified();
 
     m_FeedbackNode->SetData(NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::AcceptAllInterpolations(mitk::SliceNavigationController* slicer)
 {
   /*
    * What exactly is done here:
    * 1. We create an empty diff image for the current segmentation
    * 2. All interpolated slices are written into the diff image
    * 3. Then the diffimage is applied to the original segmentation
    */
   if (m_Segmentation)
   {
     //making interpolation separately undoable
     mitk::UndoStackItem::IncCurrObjectEventId();
     mitk::UndoStackItem::IncCurrGroupEventId();
     mitk::UndoStackItem::ExecuteIncrement();
 
     mitk::Image::Pointer image3D = m_Segmentation;
     unsigned int timeStep( slicer->GetTime()->GetPos() );
     if (m_Segmentation->GetDimension() == 4)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput( m_Segmentation );
       timeSelector->SetTimeNr( timeStep );
       timeSelector->Update();
       image3D = timeSelector->GetOutput();
     }
     // create a empty diff image for the undo operation
     mitk::Image::Pointer diffImage = mitk::Image::New();
     diffImage->Initialize( image3D );
 
     // Create scope for ImageWriteAccessor so that the accessor is destroyed
     // after the image is initialized. Otherwise later image access will lead to an error
     {
       mitk::ImageWriteAccessor imAccess(diffImage);
 
       // Set all pixels to zero
       mitk::PixelType pixelType( mitk::MakeScalarPixelType<unsigned char>()  );
       memset( imAccess.GetData(), 0, (pixelType.GetBpe() >> 3) * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2) );
     }
 
 
     // Since we need to shift the plane it must be clone so that the original plane isn't altered
     mitk::PlaneGeometry::Pointer reslicePlane = slicer->GetCurrentPlaneGeometry()->Clone();
 
     int sliceDimension(-1);
     int sliceIndex(-1);
     mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, reslicePlane, sliceDimension, sliceIndex );
 
     unsigned int zslices = m_Segmentation->GetDimension( sliceDimension );
     mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
 
     mitk::Point3D origin = reslicePlane->GetOrigin();
     unsigned int totalChangedSlices(0);
 
     for (unsigned int sliceIndex = 0; sliceIndex < zslices; ++sliceIndex)
     {
       // Transforming the current origin of the reslice plane
       // so that it matches the one of the next slice
       m_Segmentation->GetSlicedGeometry()->WorldToIndex(origin, origin);
       origin[sliceDimension] = sliceIndex;
       m_Segmentation->GetSlicedGeometry()->IndexToWorld(origin, origin);
       reslicePlane->SetOrigin(origin);
       //Set the slice as 'input'
       mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( sliceDimension, sliceIndex, reslicePlane, timeStep );
 
       if (interpolation.IsNotNull()) // we don't check if interpolation is necessary/sensible - but m_Interpolator does
       {
         //Setting up the reslicing pipeline which allows us to write the interpolation results back into
         //the image volume
         vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
         //set overwrite mode to true to write back to the image volume
         reslice->SetInputSlice(interpolation->GetSliceData()->GetVtkImageData(interpolation));
         reslice->SetOverwriteMode(true);
         reslice->Modified();
 
         mitk::ExtractSliceFilter::Pointer diffslicewriter =  mitk::ExtractSliceFilter::New(reslice);
         diffslicewriter->SetInput( diffImage );
         diffslicewriter->SetTimeStep( timeStep );
         diffslicewriter->SetWorldGeometry(reslicePlane);
         diffslicewriter->SetVtkOutputRequest(true);
         diffslicewriter->SetResliceTransformByGeometry( diffImage->GetTimeGeometry()->GetGeometryForTimeStep( timeStep ) );
 
         diffslicewriter->Modified();
         diffslicewriter->Update();
         ++totalChangedSlices;
       }
       mitk::ProgressBar::GetInstance()->Progress();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     if (totalChangedSlices > 0)
     {
       // store undo stack items
       if ( true )
       {
         // create do/undo operations
         mitk::ApplyDiffImageOperation* doOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
         mitk::ApplyDiffImageOperation* undoOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
         undoOp->SetFactor( -1.0 );
         std::stringstream comment;
         comment << "Confirm all interpolations (" << totalChangedSlices << ")";
         mitk::OperationEvent* undoStackItem = new mitk::OperationEvent( mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment.str() );
         mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
 
         // acutally apply the changes here to the original image
         mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation( doOp );
       }
     }
 
     m_FeedbackNode->SetData(NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::FinishInterpolation(mitk::SliceNavigationController* slicer)
 {
   //this redirect is for calling from outside
 
   if (slicer == NULL)
     OnAcceptAllInterpolationsClicked();
   else
     AcceptAllInterpolations( slicer );
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
 {
   QMenu orientationPopup(this);
   std::map<QAction*, mitk::SliceNavigationController*>::const_iterator it;
   for(it = ACTION_TO_SLICEDIMENSION.begin(); it != ACTION_TO_SLICEDIMENSION.end(); it++)
     orientationPopup.addAction(it->first);
 
   connect( &orientationPopup, SIGNAL(triggered(QAction*)), this, SLOT(OnAcceptAllPopupActivated(QAction*)) );
 
   orientationPopup.exec( QCursor::pos() );
 }
 
 void QmitkSlicesInterpolator::OnAccept3DInterpolationClicked()
 {
   if (m_InterpolatedSurfaceNode.IsNotNull() && m_InterpolatedSurfaceNode->GetData())
   {
     mitk::SurfaceToImageFilter::Pointer s2iFilter = mitk::SurfaceToImageFilter::New();
     s2iFilter->MakeOutputBinaryOn();
     s2iFilter->SetInput(dynamic_cast<mitk::Surface*>(m_InterpolatedSurfaceNode->GetData()));
 
     // check if ToolManager holds valid ReferenceData
     if (m_ToolManager->GetReferenceData(0) == NULL || m_ToolManager->GetWorkingData(0) == NULL)
     {
         return;
     }
     s2iFilter->SetImage(dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData()));
     s2iFilter->Update();
 
     mitk::DataNode* segmentationNode = m_ToolManager->GetWorkingData(0);
     segmentationNode->SetData(s2iFilter->GetOutput());
     m_CmbInterpolation->setCurrentIndex(0);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction* action)
 {
   try
   {
     std::map<QAction*, mitk::SliceNavigationController*>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find( action );
     if (iter != ACTION_TO_SLICEDIMENSION.end())
     {
       mitk::SliceNavigationController* slicer = iter->second;
       AcceptAllInterpolations( slicer );
     }
   }
   catch(...)
   {
     /* Showing message box with possible memory error */
     QMessageBox errorInfo;
     errorInfo.setWindowTitle("Interpolation Process");
     errorInfo.setIcon(QMessageBox::Critical);
     errorInfo.setText("An error occurred during interpolation. Possible cause: Not enough memory!");
     errorInfo.exec();
 
     //additional error message on std::cerr
     std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
   }
 }
 
 void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
 {
   m_2DInterpolationEnabled = on;
 
   try
   {
     if ( m_DataStorage.IsNotNull() )
     {
       if (on && !m_DataStorage->Exists(m_FeedbackNode))
       {
         m_DataStorage->Add( m_FeedbackNode );
       }
     }
   }
   catch(...)
   {
     // don't care (double add/remove)
   }
 
   if (m_ToolManager)
   {
     mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
     mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
     QWidget::setEnabled( workingNode != NULL );
 
     m_BtnApply2D->setEnabled( on );
     m_FeedbackNode->SetVisibility( on );
 
     if (!on)
     {
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       return;
     }
 
     if (workingNode)
     {
       mitk::Image* segmentation = dynamic_cast<mitk::Image*>(workingNode->GetData());
       if (segmentation)
       {
         m_Interpolator->SetSegmentationVolume( segmentation );
 
         if (referenceNode)
         {
           mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
           m_Interpolator->SetReferenceVolume( referenceImage ); // may be NULL
         }
       }
     }
   }
 
   UpdateVisibleSuggestion();
 }
 
 void QmitkSlicesInterpolator::Run3DInterpolation()
 {
   m_SurfaceInterpolator->Interpolate();
 }
 
 void QmitkSlicesInterpolator::StartUpdateInterpolationTimer()
 {
   m_Timer->start(500);
 }
 
 void QmitkSlicesInterpolator::StopUpdateInterpolationTimer()
 {
   m_Timer->stop();
   m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,0.0));
   mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::ChangeSurfaceColor()
 {
   float currentColor[3];
   m_InterpolatedSurfaceNode->GetColor(currentColor);
 
   float yellow[3] = {255.0,255.0,0.0};
 
   if( currentColor[2] == yellow[2])
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,255.0));
   }
   else
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(yellow));
   }
   m_InterpolatedSurfaceNode->Update();
   mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
 {
   m_3DInterpolationEnabled = on;
 
   this->CheckSupportedImageDimension();
   try
   {
     if ( m_DataStorage.IsNotNull() && m_ToolManager && m_3DInterpolationEnabled)
     {
       mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
 
       if (workingNode)
       {
         bool isInterpolationResult(false);
         workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
 
         if ((workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
             !isInterpolationResult && m_3DInterpolationEnabled)
         {
           int ret = QMessageBox::Yes;
 
           if (m_SurfaceInterpolator->EstimatePortionOfNeededMemory() > 0.5)
           {
             QMessageBox msgBox;
             msgBox.setText("Due to short handed system memory the 3D interpolation may be very slow!");
             msgBox.setInformativeText("Are you sure you want to activate the 3D interpolation?");
             msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
             ret = msgBox.exec();
           }
 
           if (m_Watcher.isRunning())
             m_Watcher.waitForFinished();
 
           if (ret == QMessageBox::Yes)
           {
             m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
             m_Watcher.setFuture(m_Future);
           }
           else
           {
             m_CmbInterpolation->setCurrentIndex(0);
           }
         }
         else if (!m_3DInterpolationEnabled)
         {
           this->Show3DInterpolationResult(false);
           m_BtnApply3D->setEnabled(m_3DInterpolationEnabled);
         }
       }
       else
       {
         QWidget::setEnabled( false );
         m_ChkShowPositionNodes->setEnabled(m_3DInterpolationEnabled);
       }
     }
     if (!m_3DInterpolationEnabled)
     {
        this->Show3DInterpolationResult(false);
        m_BtnApply3D->setEnabled(m_3DInterpolationEnabled);
     }
   }
   catch(...)
   {
     MITK_ERROR<<"Error with 3D surface interpolation!";
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::EnableInterpolation(bool on)
 {
   // only to be called from the outside world
   // just a redirection to OnInterpolationActivated
   OnInterpolationActivated(on);
 }
 
 void QmitkSlicesInterpolator::Enable3DInterpolation(bool on)
 {
   // only to be called from the outside world
   // just a redirection to OnInterpolationActivated
   On3DInterpolationActivated(on);
 }
 
 void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
 {
   if (m_2DInterpolationEnabled && m_LastSNC)
   {
     // determine which one is the current view, try to do an initial interpolation
     mitk::BaseRenderer* renderer = m_LastSNC->GetRenderer();
     if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
     {
       const mitk::TimeGeometry* timeGeometry = dynamic_cast<const mitk::TimeGeometry*>( renderer->GetWorldGeometry() );
       if (timeGeometry)
       {
         mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeGeometry*>(timeGeometry), renderer->GetSlice() );
 
         TranslateAndInterpolateChangedSlice(event, m_LastSNC);
       }
     }
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject& /*e*/)
 {
   // something (e.g. undo) changed the interpolation info, we should refresh our display
   UpdateVisibleSuggestion();
 }
 
 void QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged(const itk::EventObject& /*e*/)
 {
   if(m_3DInterpolationEnabled)
   {
     if (m_Watcher.isRunning())
       m_Watcher.waitForFinished();
     m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
     m_Watcher.setFuture(m_Future);
   }
 }
 
 void QmitkSlicesInterpolator:: SetCurrentContourListID()
 {
   // New ContourList = hide current interpolation
   Show3DInterpolationResult(false);
 
   if ( m_DataStorage.IsNotNull() && m_ToolManager && m_LastSNC )
   {
     mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
 
     if (workingNode)
     {
       bool isInterpolationResult(false);
       workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
 
       bool isVisible (workingNode->IsVisible(m_LastSNC->GetRenderer()));
       if (isVisible && !isInterpolationResult)
       {
         QWidget::setEnabled( true );
 
         //TODO Aufruf hier pruefen!
         mitk::Vector3D spacing = workingNode->GetData()->GetGeometry( m_LastSNC->GetTime()->GetPos() )->GetSpacing();
         double minSpacing (100);
         double maxSpacing (0);
         for (int i =0; i < 3; i++)
         {
           if (spacing[i] < minSpacing)
           {
             minSpacing = spacing[i];
           }
           else if (spacing[i] > maxSpacing)
           {
             maxSpacing = spacing[i];
           }
         }
 
         m_SurfaceInterpolator->SetSegmentationImage(dynamic_cast<mitk::Image*>(workingNode->GetData()));
         m_SurfaceInterpolator->SetMaxSpacing(maxSpacing);
         m_SurfaceInterpolator->SetMinSpacing(minSpacing);
         m_SurfaceInterpolator->SetDistanceImageVolume(50000);
 
         mitk::Image* segmentationImage = dynamic_cast<mitk::Image*>(workingNode->GetData());
         if (segmentationImage->GetDimension() == 3)
           m_SurfaceInterpolator->SetCurrentSegmentationInterpolationList(segmentationImage);
         else
           MITK_INFO<<"3D Interpolation is only supported for 3D images at the moment!";
 
         if (m_3DInterpolationEnabled)
         {
           if (m_Watcher.isRunning())
             m_Watcher.waitForFinished();
           m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
           m_Watcher.setFuture(m_Future);
         }
       }
     }
     else
     {
       QWidget::setEnabled(false);
     }
   }
 }
 
 void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
 {
    if (m_InterpolatedSurfaceNode.IsNotNull())
       m_InterpolatedSurfaceNode->SetVisibility(status);
 
    if (m_3DContourNode.IsNotNull())
       m_3DContourNode->SetVisibility(status, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 
    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::CheckSupportedImageDimension()
 {
   if (m_3DInterpolationEnabled && m_Segmentation->GetDimension() != 3)
   {
     QMessageBox info;
     info.setWindowTitle("3D Interpolation Process");
     info.setIcon(QMessageBox::Information);
     info.setText("3D Interpolation is only supported for 3D images at the moment!");
     info.exec();
     m_CmbInterpolation->setCurrentIndex(0);
   }
 }
 
 void QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted(const itk::Object *sender, const itk::EventObject& /*e*/)
 {
   //Don't know how to avoid const_cast here?!
   mitk::SliceNavigationController* slicer = dynamic_cast<mitk::SliceNavigationController*>(const_cast<itk::Object*>(sender));
   if (slicer)
   {
     m_ControllerToTimeObserverTag.remove(slicer);
     m_ControllerToSliceObserverTag.remove(slicer);
     m_ControllerToDeleteObserverTag.remove(slicer);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
index 30f41c4acd..f3f152e935 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
@@ -1,1026 +1,1026 @@
 /*===================================================================
 
 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 "QmitkDataManagerView.h"
 
 #include <itkOtsuThresholdImageFilter.h>
 
 //# Own Includes
 //## mitk
 #include "mitkDataStorageEditorInput.h"
 #include "mitkIDataStorageReference.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkColorProperty.h"
 #include "mitkCommon.h"
 #include "mitkNodePredicateData.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkProperties.h"
 #include <mitkNodePredicateAnd.h>
 #include <mitkITKImageImport.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIRenderingManager.h>
 #include <mitkImageCast.h>
 //## Qmitk
 #include <QmitkDnDFrameWidget.h>
 #include <QmitkDataStorageTableModel.h>
 #include <QmitkIOUtil.h>
 #include <QmitkDataStorageTreeModel.h>
 #include <QmitkCustomVariants.h>
 #include "src/internal/QmitkNodeTableViewKeyFilter.h"
 #include "src/internal/QmitkInfoDialog.h"
 #include "src/internal/QmitkDataManagerItemDelegate.h"
 //## Berry
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIEditorRegistry.h>
 
 //# Toolkit Includes
 #include <QTableView>
 #include <QGroupBox>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QListView>
 #include <QMenu>
 #include <QAction>
 #include <QComboBox>
 #include <QApplication>
 #include <QCursor>
 #include <QHeaderView>
 #include <QTreeView>
 #include <QWidgetAction>
 #include <QSplitter>
 #include <QPushButton>
 #include <QMotifStyle>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QToolBar>
 #include <QKeyEvent>
 #include <QColor>
 #include <QColorDialog>
 #include <QSizePolicy>
 #include <QSignalMapper>
 
 #include "mitkDataNodeObject.h"
 #include "mitkIContextMenuAction.h"
 #include "berryIExtensionPointService.h"
 #include "mitkRenderingModeProperty.h"
 
 const std::string QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager";
 
 QmitkDataManagerView::QmitkDataManagerView()
     : m_GlobalReinitOnNodeDelete(true),
       m_ItemDelegate(NULL)
 {
 }
 
 QmitkDataManagerView::~QmitkDataManagerView()
 {
   //Remove all registered actions from each descriptor
   for (std::vector< std::pair< QmitkNodeDescriptor*, QAction* > >::iterator it = m_DescriptorActionList.begin();it != m_DescriptorActionList.end(); it++)
   {
     // first== the NodeDescriptor; second== the registered QAction
     (it->first)->RemoveAction(it->second);
   }
 }
 
 void QmitkDataManagerView::CreateQtPartControl(QWidget* parent)
 {
   m_CurrentRowCount = 0;
   m_Parent = parent;
   //# Preferences
   berry::IPreferencesService::Pointer prefService
     = berry::Platform::GetServiceRegistry()
     .GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
 
   berry::IBerryPreferences::Pointer prefs
       = (prefService->GetSystemPreferences()->Node(VIEW_ID))
         .Cast<berry::IBerryPreferences>();
   assert( prefs );
   prefs->OnChanged.AddListener( berry::MessageDelegate1<QmitkDataManagerView
     , const berry::IBerryPreferences*>( this
       , &QmitkDataManagerView::OnPreferencesChanged ) );
 
   //# GUI
   m_NodeTreeModel = new QmitkDataStorageTreeModel(this->GetDataStorage());
   m_NodeTreeModel->setParent( parent );
   m_NodeTreeModel->SetPlaceNewNodesOnTop(
       prefs->GetBool("Place new nodes on top", true) );
   m_NodeTreeModel->SetShowHelperObjects(
     prefs->GetBool("Show helper objects", false) );
   m_NodeTreeModel->SetShowNodesContainingNoData(
     prefs->GetBool("Show nodes containing no data", false) );
   m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
 
   //# Tree View (experimental)
   m_NodeTreeView = new QTreeView;
   m_NodeTreeView->setHeaderHidden(true);
   m_NodeTreeView->setSelectionMode( QAbstractItemView::ExtendedSelection );
   m_NodeTreeView->setSelectionBehavior( QAbstractItemView::SelectRows );
   m_NodeTreeView->setAlternatingRowColors(true);
   m_NodeTreeView->setDragEnabled(true);
   m_NodeTreeView->setDropIndicatorShown(true);
   m_NodeTreeView->setAcceptDrops(true);
   m_NodeTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
   m_NodeTreeView->setModel(m_NodeTreeModel);
   m_NodeTreeView->setTextElideMode(Qt::ElideMiddle);
   m_NodeTreeView->installEventFilter(new QmitkNodeTableViewKeyFilter(this));
 
   m_ItemDelegate = new QmitkDataManagerItemDelegate(m_NodeTreeView);
   m_NodeTreeView->setItemDelegate(m_ItemDelegate);
 
   QObject::connect( m_NodeTreeView, SIGNAL(customContextMenuRequested(const QPoint&))
     , this, SLOT(NodeTableViewContextMenuRequested(const QPoint&)) );
   QObject::connect( m_NodeTreeModel, SIGNAL(rowsInserted (const QModelIndex&, int, int))
     , this, SLOT(NodeTreeViewRowsInserted ( const QModelIndex&, int, int )) );
   QObject::connect( m_NodeTreeModel, SIGNAL(rowsRemoved (const QModelIndex&, int, int))
     , this, SLOT(NodeTreeViewRowsRemoved( const QModelIndex&, int, int )) );
   QObject::connect( m_NodeTreeView->selectionModel()
     , SIGNAL( selectionChanged ( const QItemSelection &, const QItemSelection & ) )
     , this
     , SLOT( NodeSelectionChanged ( const QItemSelection &, const QItemSelection & ) ) );
 
   //# m_NodeMenu
   m_NodeMenu = new QMenu(m_NodeTreeView);
 
   // # Actions
   berry::IEditorRegistry* editorRegistry = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
   std::list<berry::IEditorDescriptor::Pointer> editors = editorRegistry->GetEditors("*.mitk");
   if (editors.size() > 1)
   {
     m_ShowInMapper = new QSignalMapper(this);
     foreach(berry::IEditorDescriptor::Pointer descriptor, editors)
     {
       QAction* action = new QAction(QString::fromStdString(descriptor->GetLabel()), this);
       m_ShowInActions << action;
       m_ShowInMapper->connect(action, SIGNAL(triggered()), m_ShowInMapper, SLOT(map()));
       m_ShowInMapper->setMapping(action, QString::fromStdString(descriptor->GetId()));
     }
     connect(m_ShowInMapper, SIGNAL(mapped(QString)), this, SLOT(ShowIn(QString)));
   }
 
   QmitkNodeDescriptor* unknownDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetUnknownDataNodeDescriptor();
 
   QmitkNodeDescriptor* imageDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Image");
 
   QmitkNodeDescriptor* surfaceDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Surface");
 
   QAction* globalReinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), "Global Reinit", this);
   QObject::connect( globalReinitAction, SIGNAL( triggered(bool) )
     , this, SLOT( GlobalReinit(bool) ) );
   unknownDataNodeDescriptor->AddAction(globalReinitAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor, globalReinitAction));
 
   QAction* saveAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"), "Save...", this);
   QObject::connect( saveAction, SIGNAL( triggered(bool) )
     , this, SLOT( SaveSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(saveAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,saveAction));
 
   QAction* removeAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"), "Remove", this);
   QObject::connect( removeAction, SIGNAL( triggered(bool) )
     , this, SLOT( RemoveSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(removeAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,removeAction));
 
   QAction* reinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), "Reinit", this);
   QObject::connect( reinitAction, SIGNAL( triggered(bool) )
     , this, SLOT( ReinitSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(reinitAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,reinitAction));
 
   // find contextMenuAction extension points and add them to the node descriptor
   berry::IExtensionPointService::Pointer extensionPointService = berry::Platform::GetExtensionPointService();
   berry::IConfigurationElement::vector cmActions(
     extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions") );
   berry::IConfigurationElement::vector::iterator cmActionsIt;
 
   std::string cmNodeDescriptorName;
   std::string cmLabel;
   std::string cmIcon;
   std::string cmClass;
 
   QmitkNodeDescriptor* tmpDescriptor;
   QAction* contextMenuAction;
   QVariant cmActionDataIt;
   m_ConfElements.clear();
 
   int i=1;
   for (cmActionsIt = cmActions.begin()
     ; cmActionsIt != cmActions.end()
     ; ++cmActionsIt)
   {
     cmIcon.erase();
     if((*cmActionsIt)->GetAttribute("nodeDescriptorName", cmNodeDescriptorName)
       && (*cmActionsIt)->GetAttribute("label", cmLabel)
       && (*cmActionsIt)->GetAttribute("class", cmClass))
     {
       (*cmActionsIt)->GetAttribute("icon", cmIcon);
       // create context menu entry here
       tmpDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(QString::fromStdString(cmNodeDescriptorName));
       if(!tmpDescriptor)
       {
         MITK_WARN << "cannot add action \"" << cmLabel << "\" because descriptor " << cmNodeDescriptorName << " does not exist";
         continue;
       }
       contextMenuAction = new QAction( QString::fromStdString(cmLabel), parent);
       tmpDescriptor->AddAction(contextMenuAction);
       m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(tmpDescriptor,contextMenuAction));
       m_ConfElements[contextMenuAction] = *cmActionsIt;
 
       cmActionDataIt.setValue<int>(i);
       contextMenuAction->setData( cmActionDataIt );
       connect( contextMenuAction, SIGNAL( triggered(bool) ) , this, SLOT( ContextMenuActionTriggered(bool) ) );
       ++i;
     }
   }
 
   m_OpacitySlider = new QSlider;
   m_OpacitySlider->setMinimum(0);
   m_OpacitySlider->setMaximum(100);
   m_OpacitySlider->setOrientation(Qt::Horizontal);
   QObject::connect( m_OpacitySlider, SIGNAL( valueChanged(int) )
     , this, SLOT( OpacityChanged(int) ) );
 
   QLabel* _OpacityLabel = new QLabel("Opacity: ");
   QHBoxLayout* _OpacityWidgetLayout = new QHBoxLayout;
   _OpacityWidgetLayout->setContentsMargins(4,4,4,4);
   _OpacityWidgetLayout->addWidget(_OpacityLabel);
   _OpacityWidgetLayout->addWidget(m_OpacitySlider);
   QWidget* _OpacityWidget = new QWidget;
   _OpacityWidget->setLayout(_OpacityWidgetLayout);
 
   QWidgetAction* opacityAction = new QWidgetAction(this);
   opacityAction ->setDefaultWidget(_OpacityWidget);
   QObject::connect( opacityAction , SIGNAL( changed() )
     , this, SLOT( OpacityActionChanged() ) );
   unknownDataNodeDescriptor->AddAction(opacityAction , false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,opacityAction));
 
   m_ColorButton = new QPushButton;
   m_ColorButton->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum);
   //m_ColorButton->setText("Change color");
   QObject::connect( m_ColorButton, SIGNAL( clicked() )
     , this, SLOT( ColorChanged() ) );
 
   QLabel* _ColorLabel = new QLabel("Color: ");
   _ColorLabel->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
   QHBoxLayout* _ColorWidgetLayout = new QHBoxLayout;
   _ColorWidgetLayout->setContentsMargins(4,4,4,4);
   _ColorWidgetLayout->addWidget(_ColorLabel);
   _ColorWidgetLayout->addWidget(m_ColorButton);
   QWidget* _ColorWidget = new QWidget;
   _ColorWidget->setLayout(_ColorWidgetLayout);
 
   QWidgetAction* colorAction = new QWidgetAction(this);
   colorAction->setDefaultWidget(_ColorWidget);
   QObject::connect( colorAction, SIGNAL( changed() )
     , this, SLOT( ColorActionChanged() ) );
   unknownDataNodeDescriptor->AddAction(colorAction, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,colorAction));
 
   m_TextureInterpolation = new QAction("Texture Interpolation", this);
   m_TextureInterpolation->setCheckable ( true );
   QObject::connect( m_TextureInterpolation, SIGNAL( changed() )
     , this, SLOT( TextureInterpolationChanged() ) );
   QObject::connect( m_TextureInterpolation, SIGNAL( toggled(bool) )
     , this, SLOT( TextureInterpolationToggled(bool) ) );
   imageDataNodeDescriptor->AddAction(m_TextureInterpolation, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor,m_TextureInterpolation));
 
   m_ColormapAction = new QAction("Colormap", this);
   m_ColormapAction->setMenu(new QMenu);
   QObject::connect( m_ColormapAction->menu(), SIGNAL( aboutToShow() )
     , this, SLOT( ColormapMenuAboutToShow() ) );
   imageDataNodeDescriptor->AddAction(m_ColormapAction, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor, m_ColormapAction));
 
   m_SurfaceRepresentation = new QAction("Surface Representation", this);
   m_SurfaceRepresentation->setMenu(new QMenu);
   QObject::connect( m_SurfaceRepresentation->menu(), SIGNAL( aboutToShow() )
     , this, SLOT( SurfaceRepresentationMenuAboutToShow() ) );
   surfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentation, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(surfaceDataNodeDescriptor, m_SurfaceRepresentation));
 
   QAction* showOnlySelectedNodes
     = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png")
     , "Show only selected nodes", this);
   QObject::connect( showOnlySelectedNodes, SIGNAL( triggered(bool) )
     , this, SLOT( ShowOnlySelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(showOnlySelectedNodes);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor, showOnlySelectedNodes));
 
   QAction* toggleSelectedVisibility
     = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png")
     , "Toggle visibility", this);
   QObject::connect( toggleSelectedVisibility, SIGNAL( triggered(bool) )
     , this, SLOT( ToggleVisibilityOfSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(toggleSelectedVisibility);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,toggleSelectedVisibility));
 
   QAction* actionShowInfoDialog
     = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png")
     , "Details...", this);
   QObject::connect( actionShowInfoDialog, SIGNAL( triggered(bool) )
     , this, SLOT( ShowInfoDialogForSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(actionShowInfoDialog);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,actionShowInfoDialog));
 
   //obsolete...
   //QAction* otsuFilterAction = new QAction("Apply Otsu Filter", this);
   //QObject::connect( otsuFilterAction, SIGNAL( triggered(bool) )
   //  , this, SLOT( OtsuFilter(bool) ) );
   // //Otsu filter does not work properly, remove it temporarily
   // imageDataNodeDescriptor->AddAction(otsuFilterAction);
   // m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor,otsuFilterAction));
 
   QGridLayout* _DndFrameWidgetLayout = new QGridLayout;
   _DndFrameWidgetLayout->addWidget(m_NodeTreeView, 0, 0);
   _DndFrameWidgetLayout->setContentsMargins(0,0,0,0);
 
   m_DndFrameWidget = new QmitkDnDFrameWidget(m_Parent);
   m_DndFrameWidget->setLayout(_DndFrameWidgetLayout);
 
   QVBoxLayout* layout = new QVBoxLayout(parent);
   layout->addWidget(m_DndFrameWidget);
   layout->setContentsMargins(0,0,0,0);
 
   m_Parent->setLayout(layout);
 }
 
 void QmitkDataManagerView::SetFocus()
 {
 }
 
 void QmitkDataManagerView::ContextMenuActionTriggered( bool )
 {
   QAction* action = qobject_cast<QAction*> ( sender() );
 
   std::map<QAction*, berry::IConfigurationElement::Pointer>::iterator it
     = m_ConfElements.find( action );
   if( it == m_ConfElements.end() )
   {
     MITK_WARN << "associated conf element for action " << action->text().toStdString() << " not found";
     return;
   }
   berry::IConfigurationElement::Pointer confElem = it->second;
   mitk::IContextMenuAction* contextMenuAction = confElem->CreateExecutableExtension<mitk::IContextMenuAction>("class");
 
   std::string className;
   std::string smoothed;
   confElem->GetAttribute("class", className);
   confElem->GetAttribute("smoothed", smoothed);
 
   if(className == "QmitkCreatePolygonModelAction")
   {
     contextMenuAction->SetDataStorage(this->GetDataStorage());
     if(smoothed == "false")
     {
       contextMenuAction->SetSmoothed(false);
     }
     else
     {
       contextMenuAction->SetSmoothed(true);
     }
     contextMenuAction->SetDecimated(m_SurfaceDecimation);
   }
   else if(className == "QmitkStatisticsAction")
   {
     contextMenuAction->SetFunctionality(this);
   }
   else if(className == "QmitkCreateSimulationAction")
   {
     contextMenuAction->SetDataStorage(this->GetDataStorage());
   }
   contextMenuAction->Run( this->GetCurrentSelection() ); // run the action
 }
 
 void QmitkDataManagerView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   if( m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() !=  prefs->GetBool("Place new nodes on top", true) )
     m_NodeTreeModel->SetPlaceNewNodesOnTop( !m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() );
 
   if( m_NodeTreeModel->GetShowHelperObjectsFlag()!= prefs->GetBool("Show helper objects", false) )
     m_NodeTreeModel->SetShowHelperObjects( !m_NodeTreeModel->GetShowHelperObjectsFlag() );
 
   if( m_NodeTreeModel->GetShowNodesContainingNoDataFlag()!= prefs->GetBool("Show nodes containing no data", false) )
     m_NodeTreeModel->SetShowNodesContainingNoData( !m_NodeTreeModel->GetShowNodesContainingNoDataFlag() );
 
   m_GlobalReinitOnNodeDelete = prefs->GetBool("Call global reinit if node is deleted", true);
 
   m_NodeTreeView->expandAll();
 
   m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
 
   this->GlobalReinit();
 
 
 }
 
 void QmitkDataManagerView::NodeTableViewContextMenuRequested( const QPoint & pos )
 {
   QModelIndex selected = m_NodeTreeView->indexAt ( pos );
   mitk::DataNode::Pointer node = m_NodeTreeModel->GetNode(selected);
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   if(!selectedNodes.isEmpty())
   {
     m_NodeMenu->clear();
     QList<QAction*> actions;
     if(selectedNodes.size() == 1 )
     {
       actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(node);
 
       for(QList<QAction*>::iterator it = actions.begin(); it != actions.end(); ++it)
       {
         (*it)->setData(QVariant::fromValue(node.GetPointer()));
       }
     }
     else
       actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(selectedNodes);
 
     if (!m_ShowInActions.isEmpty())
     {
       QMenu* showInMenu = m_NodeMenu->addMenu("Show In");
       showInMenu->addActions(m_ShowInActions);
     }
     m_NodeMenu->addActions(actions);
     m_NodeMenu->popup(QCursor::pos());
   }
 }
 
 void QmitkDataManagerView::OpacityChanged(int value)
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(node)
   {
     float opacity = static_cast<float>(value)/100.0f;
     node->SetFloatProperty("opacity", opacity);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkDataManagerView::OpacityActionChanged()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(node)
   {
     float opacity = 0.0;
     if(node->GetFloatProperty("opacity", opacity))
     {
       m_OpacitySlider->setValue(static_cast<int>(opacity*100));
     }
   }
 }
 
 void QmitkDataManagerView::ColorChanged()
  {
    mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
    if(node)
    {
     mitk::Color color;
     mitk::ColorProperty::Pointer colorProp;
     node->GetProperty(colorProp,"color");
     if(colorProp.IsNull())
       return;
     color = colorProp->GetValue();
     QColor initial(color.GetRed()*255,color.GetGreen()*255,color.GetBlue()*255);
     QColor qcolor = QColorDialog::getColor(initial,0,QString("Change color"));
     if (!qcolor.isValid())
       return;
     m_ColorButton->setAutoFillBackground(true);
     node->SetProperty("color",mitk::ColorProperty::New(qcolor.red()/255.0,qcolor.green()/255.0,qcolor.blue()/255.0));
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
    }
  }
 
 void QmitkDataManagerView::ColorActionChanged()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(node)
   {
     mitk::Color color;
     mitk::ColorProperty::Pointer colorProp;
     node->GetProperty(colorProp,"color");
     if(colorProp.IsNull())
       return;
     color = colorProp->GetValue();
 
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color[0]*255));
     styleSheet.append(",");
     styleSheet.append(QString::number(color[1]*255));
     styleSheet.append(",");
     styleSheet.append(QString::number(color[2]*255));
     styleSheet.append(")");
     m_ColorButton->setStyleSheet(styleSheet);
   }
 }
 
 void QmitkDataManagerView::TextureInterpolationChanged()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(node)
   {
     bool textureInterpolation = false;
     node->GetBoolProperty("texture interpolation", textureInterpolation);
     m_TextureInterpolation->setChecked(textureInterpolation);
   }
 }
 
 void QmitkDataManagerView::TextureInterpolationToggled( bool checked )
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(node)
   {
     node->SetBoolProperty("texture interpolation", checked);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
 }
 
 void QmitkDataManagerView::ColormapActionToggled( bool /*checked*/ )
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(!node)
     return;
 
   mitk::LookupTableProperty::Pointer lookupTableProperty =
     dynamic_cast<mitk::LookupTableProperty*>(node->GetProperty("LookupTable"));
   if (!lookupTableProperty)
     return;
 
   QAction* senderAction = qobject_cast<QAction*>(QObject::sender());
   if(!senderAction)
     return;
 
   std::string activatedItem = senderAction->text().toStdString();
 
   mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
   if (!lookupTable)
     return;
 
   lookupTable->SetType(activatedItem);
   lookupTableProperty->SetValue(lookupTable);
   mitk::RenderingModeProperty::Pointer renderingMode =
     dynamic_cast<mitk::RenderingModeProperty*>(node->GetProperty("Image Rendering.Mode"));
   renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ColormapMenuAboutToShow()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(!node)
     return;
 
   mitk::LookupTableProperty::Pointer lookupTableProperty =
     dynamic_cast<mitk::LookupTableProperty*>(node->GetProperty("LookupTable"));
   if (!lookupTableProperty)
   {
     mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
     lookupTableProperty = mitk::LookupTableProperty::New();
     lookupTableProperty->SetLookupTable(mitkLut);
     node->SetProperty("LookupTable", lookupTableProperty);
   }
 
   mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
   if (!lookupTable)
     return;
 
   m_ColormapAction->menu()->clear();
   QAction* tmp;
 
   int i = 0;
   std::string lutType = lookupTable->typenameList[i];
 
   while (lutType != "END_OF_ARRAY")
   {
     tmp = m_ColormapAction->menu()->addAction(QString::fromStdString(lutType));
     tmp->setCheckable(true);
 
     if (lutType == lookupTable->GetActiveTypeAsString())
     {
       tmp->setChecked(true);
     }
 
     QObject::connect(tmp, SIGNAL(triggered(bool)), this, SLOT(ColormapActionToggled(bool)));
 
     lutType = lookupTable->typenameList[++i];
   }
 }
 
 void QmitkDataManagerView::SurfaceRepresentationMenuAboutToShow()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(!node)
     return;
 
   mitk::EnumerationProperty* representationProp =
       dynamic_cast<mitk::EnumerationProperty*> (node->GetProperty("material.representation"));
   if(!representationProp)
     return;
 
   // clear menu
   m_SurfaceRepresentation->menu()->clear();
   QAction* tmp;
 
   // create menu entries
   for(mitk::EnumerationProperty::EnumConstIterator it=representationProp->Begin(); it!=representationProp->End()
     ; it++)
   {
     tmp = m_SurfaceRepresentation->menu()->addAction(QString::fromStdString(it->second));
     tmp->setCheckable(true);
 
     if(it->second == representationProp->GetValueAsString())
     {
       tmp->setChecked(true);
     }
 
     QObject::connect( tmp, SIGNAL( triggered(bool) )
       , this, SLOT( SurfaceRepresentationActionToggled(bool) ) );
   }
 }
 
 void QmitkDataManagerView::SurfaceRepresentationActionToggled( bool /*checked*/ )
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
   if(!node)
     return;
 
   mitk::EnumerationProperty* representationProp =
       dynamic_cast<mitk::EnumerationProperty*> (node->GetProperty("material.representation"));
   if(!representationProp)
     return;
 
   QAction* senderAction = qobject_cast<QAction*> ( QObject::sender() );
 
   if(!senderAction)
     return;
 
   std::string activatedItem = senderAction->text().toStdString();
 
   if ( activatedItem != representationProp->GetValueAsString() )
   {
     if ( representationProp->IsValidEnumerationValue( activatedItem ) )
     {
       representationProp->SetValue( activatedItem );
       representationProp->InvokeEvent( itk::ModifiedEvent() );
       representationProp->Modified();
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 
 }
 
 void QmitkDataManagerView::SaveSelectedNodes( bool )
 {
   QModelIndexList indexesOfSelectedRows = m_NodeTreeView->selectionModel()->selectedRows();
 
   mitk::DataNode* node = 0;
   unsigned int indexesOfSelectedRowsSize = indexesOfSelectedRows.size();
   for (unsigned int i = 0; i<indexesOfSelectedRowsSize; ++i)
   {
     node = m_NodeTreeModel->GetNode(indexesOfSelectedRows.at(i));
     // if node is not defined or if the node contains geometry data do not remove it
     if ( node != 0 )
     {
       mitk::BaseData::Pointer data = node->GetData();
       if (data.IsNotNull())
       {
         QString error;
         try
         {
            QmitkIOUtil::SaveBaseDataWithDialog( data.GetPointer(), node->GetName().c_str(), m_Parent );
         }
         catch(std::exception& e)
         {
           error = e.what();
         }
         catch(...)
         {
           error = "Unknown error occured";
         }
         if( !error.isEmpty() )
           QMessageBox::critical( m_Parent, "Error saving...", error );
       }
     }
   }
 }
 
 void QmitkDataManagerView::ReinitSelectedNodes( bool )
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   if (renderWindow == NULL)
     renderWindow = this->OpenRenderWindowPart(false);
 
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   foreach(mitk::DataNode::Pointer node, selectedNodes)
   {
     mitk::BaseData::Pointer basedata = node->GetData();
     if ( basedata.IsNotNull() &&
       basedata->GetTimeGeometry()->IsValid() )
     {
       renderWindow->GetRenderingManager()->InitializeViews(
           basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       renderWindow->GetRenderingManager()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkDataManagerView::RemoveSelectedNodes( bool )
 {
   QModelIndexList indexesOfSelectedRows = m_NodeTreeView->selectionModel()->selectedRows();
   if(indexesOfSelectedRows.size() < 1)
   {
     return;
   }
   std::vector<mitk::DataNode*> selectedNodes;
 
   mitk::DataNode* node = 0;
   QString question = tr("Do you really want to remove ");
 
   for (QModelIndexList::iterator it = indexesOfSelectedRows.begin()
     ; it != indexesOfSelectedRows.end(); it++)
   {
     node = m_NodeTreeModel->GetNode(*it);
     // if node is not defined or if the node contains geometry data do not remove it
-    if ( node != 0 /*& strcmp(node->GetData()->GetNameOfClass(), "Geometry2DData") != 0*/ )
+    if ( node != 0 /*& strcmp(node->GetData()->GetNameOfClass(), "PlaneGeometryData") != 0*/ )
     {
       selectedNodes.push_back(node);
       question.append(QString::fromStdString(node->GetName()));
       question.append(", ");
     }
   }
   // remove the last two characters = ", "
   question = question.remove(question.size()-2, 2);
   question.append(" from data storage?");
 
   QMessageBox::StandardButton answerButton = QMessageBox::question( m_Parent
     , tr("DataManager")
     , question
     , QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
   if(answerButton == QMessageBox::Yes)
   {
     for (std::vector<mitk::DataNode*>::iterator it = selectedNodes.begin()
       ; it != selectedNodes.end(); it++)
     {
       node = *it;
       this->GetDataStorage()->Remove(node);
       if (m_GlobalReinitOnNodeDelete)
           this->GlobalReinit(false);
     }
   }
 }
 
 void QmitkDataManagerView::MakeAllNodesInvisible( bool )
 {
   QList<mitk::DataNode::Pointer> nodes = m_NodeTreeModel->GetNodeSet();
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     node->SetVisibility(false);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ShowOnlySelectedNodes( bool )
 {
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
   QList<mitk::DataNode::Pointer> allNodes = m_NodeTreeModel->GetNodeSet();
 
   foreach(mitk::DataNode::Pointer node, allNodes)
   {
     node->SetVisibility(selectedNodes.contains(node));
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ToggleVisibilityOfSelectedNodes( bool )
 {
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   bool isVisible = false;
   foreach(mitk::DataNode::Pointer node, selectedNodes)
   {
     isVisible = false;
     node->GetBoolProperty("visible", isVisible);
     node->SetVisibility(!isVisible);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ShowInfoDialogForSelectedNodes( bool )
 {
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   QmitkInfoDialog _QmitkInfoDialog(selectedNodes, this->m_Parent);
   _QmitkInfoDialog.exec();
 }
 
 void QmitkDataManagerView::Load( bool )
 {
   QStringList fileNames = QFileDialog::getOpenFileNames(NULL, "Load data", "", mitk::CoreObjectFactory::GetInstance()->GetFileExtensions());
   for ( QStringList::Iterator it = fileNames.begin(); it != fileNames.end(); ++it )
   {
     FileOpen((*it).toAscii(), 0);
   }
 }
 
 void QmitkDataManagerView::FileOpen( const char * fileName, mitk::DataNode* parentNode )
 {
   mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
 
   try
   {
     factory->SetFileName( fileName );
 
     QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
 
     factory->Update();
 
     for ( unsigned int i = 0 ; i < factory->GetNumberOfOutputs( ); ++i )
     {
       mitk::DataNode::Pointer node = factory->GetOutput( i );
       if ( ( node.IsNotNull() ) && ( node->GetData() != NULL ) )
       {
         this->GetDataStorage()->Add(node, parentNode);
         mitk::BaseData::Pointer basedata = node->GetData();
         mitk::RenderingManager::GetInstance()->InitializeViews(
           basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
   }
   catch ( itk::ExceptionObject & ex )
   {
     itkGenericOutputMacro( << "Exception during file open: " << ex );
   }
 
   QApplication::restoreOverrideCursor();
 }
 
 QItemSelectionModel *QmitkDataManagerView::GetDataNodeSelectionModel() const
 {
   return m_NodeTreeView->selectionModel();
 }
 
 void QmitkDataManagerView::GlobalReinit( bool )
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   if (renderWindow == NULL)
     renderWindow = this->OpenRenderWindowPart(false);
 
   // no render window available
   if (renderWindow == NULL) return;
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 }
 
 void QmitkDataManagerView::OtsuFilter( bool )
 {
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   mitk::Image::Pointer mitkImage = 0;
   foreach(mitk::DataNode::Pointer node, selectedNodes)
   {
     mitkImage = dynamic_cast<mitk::Image*>( node->GetData() );
 
     if(mitkImage.IsNull())
       continue;
 
     try
     {
       // get selected mitk image
       const unsigned short dim = 3;
       typedef short InputPixelType;
       typedef unsigned char OutputPixelType;
 
       typedef itk::Image< InputPixelType, dim > InputImageType;
       typedef itk::Image< OutputPixelType, dim > OutputImageType;
 
       typedef itk::OtsuThresholdImageFilter< InputImageType, OutputImageType > FilterType;
       FilterType::Pointer filter = FilterType::New();
 
       filter->SetOutsideValue( 1 );
       filter->SetInsideValue( 0 );
 
       InputImageType::Pointer itkImage;
       mitk::CastToItkImage(mitkImage, itkImage);
 
       filter->SetInput( itkImage );
 
       filter->Update();
 
       mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
       std::string nameOfResultImage = node->GetName();
       nameOfResultImage.append("Otsu");
       resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
       resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
       resultNode->SetData( mitk::ImportItkImage(filter->GetOutput())->Clone());
 
       this->GetDataStorage()->Add(resultNode, node);
 
     }
     catch( std::exception& err )
     {
       MITK_ERROR(this->GetClassName()) << err.what();
     }
 
   }
 }
 void QmitkDataManagerView::NodeTreeViewRowsRemoved (
   const QModelIndex & /*parent*/, int /*start*/, int /*end*/ )
 {
   m_CurrentRowCount = m_NodeTreeModel->rowCount();
 }
 void QmitkDataManagerView::NodeTreeViewRowsInserted( const QModelIndex & parent, int, int )
 {
   m_NodeTreeView->setExpanded(parent, true);
 
   // a new row was inserted
   if( m_CurrentRowCount == 0 && m_NodeTreeModel->rowCount() == 1 )
   {
     this->OpenRenderWindowPart();
     m_CurrentRowCount = m_NodeTreeModel->rowCount();
     /*
     std::vector<mitk::DataNode*> nodes = m_NodeTreeModel->GetNodeSet();
     if(nodes.size() == 1)
     {
       QModelIndex treeIndex = m_NodeTreeModel->GetIndex(nodes.front());
       m_NodeTreeView->selectionModel()->setCurrentIndex( treeIndex, QItemSelectionModel::ClearAndSelect );
     }
     */
   }
 }
 
 void QmitkDataManagerView::NodeSelectionChanged( const QItemSelection & /*selected*/, const QItemSelection & /*deselected*/ )
 {
   QList<mitk::DataNode::Pointer> nodes = m_NodeTreeModel->GetNodeSet();
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if ( node.IsNotNull() )
       node->SetBoolProperty("selected", false);
   }
 
   nodes.clear();
   nodes = this->GetCurrentSelection();
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if ( node.IsNotNull() )
       node->SetBoolProperty("selected", true);
   }
   //changing the selection does NOT require any rendering processes!
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ShowIn(const QString &editorId)
 {
   berry::IWorkbenchPage::Pointer page = this->GetSite()->GetPage();
   berry::IEditorInput::Pointer input(new mitk::DataStorageEditorInput(this->GetDataStorageReference()));
   page->OpenEditor(input, editorId.toStdString(), false, berry::IWorkbenchPage::MATCH_ID);
 }
 
 mitk::IRenderWindowPart* QmitkDataManagerView::OpenRenderWindowPart(bool activatedEditor)
 {
   if (activatedEditor)
   {
     return this->GetRenderWindowPart(QmitkAbstractView::ACTIVATE | QmitkAbstractView::OPEN);
   }
   else
   {
     return this->GetRenderWindowPart(QmitkAbstractView::BRING_TO_FRONT | QmitkAbstractView::OPEN);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index 0fa6f2ae69..3dff9397d4 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,897 +1,897 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsView.h"
 
 // Qt includes
 #include <qclipboard.h>
 #include <qscrollbar.h>
 
 // berry includes
 #include <berryIWorkbenchPage.h>
 
 // mitk includes
 #include "mitkNodePredicateDataType.h"
 #include "mitkPlanarFigureInteractor.h"
 
 // itk includes
 #include "itksys/SystemTools.hxx"
 #include <mitkILinkedRenderWindowPart.h>
 #include <QmitkRenderWindow.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
 const int QmitkImageStatisticsView::STAT_TABLE_BASE_HEIGHT = 180;
 
 QmitkImageStatisticsView::QmitkImageStatisticsView(QObject* /*parent*/, const char* /*name*/)
   : m_Controls( NULL ),
   m_TimeStepperAdapter( NULL ),
   m_SelectedImage( NULL ),
   m_SelectedImageMask( NULL ),
   m_SelectedPlanarFigure( NULL ),
   m_ImageObserverTag( -1 ),
   m_ImageMaskObserverTag( -1 ),
   m_PlanarFigureObserverTag( -1 ),
   m_TimeObserverTag( -1 ),
   m_CurrentStatisticsValid( false ),
   m_StatisticsUpdatePending( false ),
   m_DataNodeSelectionChanged ( false ),
   m_Visible(false)
 {
   this->m_CalculationThread = new QmitkImageStatisticsCalculationThread;
 }
 
 QmitkImageStatisticsView::~QmitkImageStatisticsView()
 {
   if ( m_SelectedImage != NULL )
     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
   if ( m_SelectedImageMask != NULL )
     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
   if ( m_SelectedPlanarFigure != NULL )
     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
 
   while(this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
   delete this->m_CalculationThread;
 }
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkImageStatisticsViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_ErrorMessageLabel->hide();
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
   }
 }
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(this->m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardHistogramButtonClicked()) );
     connect( (QObject*)(this->m_Controls->m_ButtonCopyStatisticsToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardStatisticsButtonClicked()) );
     connect( (QObject*)(this->m_Controls->m_IgnoreZerosCheckbox), SIGNAL(clicked()),(QObject*) this, SLOT(OnIgnoreZerosCheckboxClicked()) );
     connect( (QObject*) this->m_CalculationThread, SIGNAL(finished()),this, SLOT( OnThreadedStatisticsCalculationEnds()),Qt::QueuedConnection);
     connect( (QObject*) this, SIGNAL(StatisticsUpdate()),this, SLOT( RequestStatisticsUpdate()), Qt::QueuedConnection);
     connect( (QObject*) this->m_Controls->m_StatisticsTable, SIGNAL(cellDoubleClicked(int,int)),this, SLOT( JumpToCoordinates(int,int)) );
     connect( (QObject*) (this->m_Controls->m_barRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnBarRadioButtonSelected()));
     connect( (QObject*) (this->m_Controls->m_lineRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnLineRadioButtonSelected()));
   }
 
 }
 
 void QmitkImageStatisticsView::PartClosed( berry::IWorkbenchPartReference::Pointer )
 {
 }
 
 void QmitkImageStatisticsView::OnTimeChanged(const itk::EventObject& e)
 {
   if (this->m_SelectedDataNodes.isEmpty() || this->m_SelectedImage == NULL)
     return;
 
   const mitk::SliceNavigationController::GeometryTimeEvent* timeEvent =
     dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent*>(&e);
   assert(timeEvent != NULL);
   unsigned int timestep = timeEvent->GetPos();
 
   if (this->m_SelectedImage->GetTimeSteps() > 1)
   {
     for (unsigned int x = 0; x < this->m_Controls->m_StatisticsTable->columnCount(); x++)
     {
       for (unsigned int y = 0; y < this->m_Controls->m_StatisticsTable->rowCount(); y++)
       {
         QTableWidgetItem* item = this->m_Controls->m_StatisticsTable->item(y, x);
         if (item == NULL)
           break;
 
         if (x == timestep)
         {
           item->setBackgroundColor(Qt::yellow);
         }
         else
         {
           if (y % 2 == 0)
             item->setBackground(this->m_Controls->m_StatisticsTable->palette().base());
           else
             item->setBackground(this->m_Controls->m_StatisticsTable->palette().alternateBase());
         }
       }
     }
 
     this->m_Controls->m_StatisticsTable->viewport()->update();
   }
 
   if ((this->m_SelectedImage->GetTimeSteps() == 1 && timestep == 0) ||
       this->m_SelectedImage->GetTimeSteps() > 1)
   {
     // display histogram for selected timestep
     this->m_Controls->m_JSHistogram->ClearHistogram();
     QmitkImageStatisticsCalculationThread::HistogramType::Pointer histogram =
       this->m_CalculationThread->GetTimeStepHistogram(timestep);
 
     if (histogram.IsNotNull())
     {
       this->m_Controls->m_JSHistogram->ComputeHistogram(histogram.GetPointer());
 //      this->m_Controls->m_JSHistogram->SignalGraphChanged();
 
       // hacky way to make sure the protected SignalGraphChanged() is called
       if (this->m_Controls->m_JSHistogram->GetUseLineGraph())
       {
         this->m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
         this->m_Controls->m_JSHistogram->OnLineRadioButtonSelected();
       }
       else
       {
         this->m_Controls->m_JSHistogram->OnLineRadioButtonSelected();
         this->m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
       }
     }
   }
 }
 
 void QmitkImageStatisticsView::JumpToCoordinates(int row ,int col)
 {
   if(m_SelectedDataNodes.isEmpty())
   {
     MITK_WARN("QmitkImageStatisticsView") << "No data node selected for statistics calculation." ;
     return;
   }
 
   mitk::Point3D world;
   if (row==4)
     world = m_WorldMinList[col];
   else if (row==3)
     world = m_WorldMaxList[col];
   else
     return;
 
   mitk::IRenderWindowPart* part = this->GetRenderWindowPart();
   if (part)
   {
     part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(world);
     part->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SelectSliceByPoint(world);
     part->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SelectSliceByPoint(world);
 
     mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(), col);
     part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetGeometryTime(timeEvent);
   }
 }
 
 void QmitkImageStatisticsView::OnIgnoreZerosCheckboxClicked()
 {
   emit StatisticsUpdate();
 }
 
 void QmitkImageStatisticsView::OnClipboardHistogramButtonClicked()
 {
   if ( m_CurrentStatisticsValid )
   {
     const unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
 
     typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
     const HistogramType *histogram = this->m_CalculationThread->GetTimeStepHistogram(t).GetPointer();
 
     QString clipboard( "Measurement \t Frequency\n" );
     for ( HistogramType::ConstIterator it = histogram->Begin();
       it != histogram->End();
       ++it )
     {
       clipboard = clipboard.append( "%L1 \t %L2\n" )
         .arg( it.GetMeasurementVector()[0], 0, 'f', 2 )
         .arg( it.GetFrequency() );
     }
 
     QApplication::clipboard()->setText(
       clipboard, QClipboard::Clipboard );
   }
   else
   {
     QApplication::clipboard()->clear();
   }
 }
 
 void QmitkImageStatisticsView::OnClipboardStatisticsButtonClicked()
 {
   QLocale tempLocal;
   QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
   if ( this->m_CurrentStatisticsValid )
   {
     const std::vector<mitk::ImageStatisticsCalculator::Statistics> &statistics =
         this->m_CalculationThread->GetStatisticsData();
     const unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
         GetPos();
 
     // Copy statistics to clipboard ("%Ln" will use the default locale for
     // number formatting)
     QString clipboard( "Mean \t StdDev \t RMS \t Max \t Min \t N \t V (mm³)\n" );
     clipboard = clipboard.append( "%L1 \t %L2 \t %L3 \t %L4 \t %L5 \t %L6 \t %L7" )
       .arg( statistics[t].Mean, 0, 'f', 10 )
       .arg( statistics[t].Sigma, 0, 'f', 10 )
       .arg( statistics[t].RMS, 0, 'f', 10 )
       .arg( statistics[t].Max, 0, 'f', 10 )
       .arg( statistics[t].Min, 0, 'f', 10 )
       .arg( statistics[t].N )
         .arg( m_Controls->m_StatisticsTable->item( 0, 6 )->text().toDouble(), 0, 'f', 10 );
 
     QApplication::clipboard()->setText(
       clipboard, QClipboard::Clipboard );
   }
   else
   {
     QApplication::clipboard()->clear();
   }
   QLocale::setDefault(tempLocal);
 }
 
 void QmitkImageStatisticsView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
                                                   const QList<mitk::DataNode::Pointer> &selectedNodes )
 {
   if (this->m_Visible)
   {
     this->SelectionChanged( selectedNodes );
   }
   else
   {
     this->m_DataNodeSelectionChanged = true;
   }
 }
 
 void QmitkImageStatisticsView::SelectionChanged(const QList<mitk::DataNode::Pointer> &selectedNodes)
 {
   if( this->m_StatisticsUpdatePending )
   {
     this->m_DataNodeSelectionChanged = true;
     return; // not ready for new data now!
   }
 
   if (selectedNodes.size() == this->m_SelectedDataNodes.size())
   {
     int i = 0;
     for (; i < selectedNodes.size(); ++i)
     {
       if (selectedNodes.at(i) != this->m_SelectedDataNodes.at(i))
       {
         break;
       }
     }
     // node selection did not change
     if (i == selectedNodes.size()) return;
   }
 
   this->ReinitData();
   if (selectedNodes.isEmpty())
   {
     m_Controls->m_JSHistogram->ClearHistogram();
     m_Controls->m_lineRadioButton->setEnabled(true);
     m_Controls->m_barRadioButton->setEnabled(true);
     m_Controls->m_InfoLabel->setText(QString(""));
 
     //   m_Controls->horizontalLayout_3->setEnabled(false);
     m_Controls->groupBox->setEnabled(false);
     m_Controls->groupBox_3->setEnabled(false);
   }
   else
   {
     //  m_Controls->horizontalLayout_3->setEnabled(true);
     m_Controls->groupBox->setEnabled(true);
     m_Controls->groupBox_3->setEnabled(true);
   }
   if(selectedNodes.size() == 1 || selectedNodes.size() == 2)
   {
     bool isBinary = false;
     selectedNodes.value(0)->GetBoolProperty("binary",isBinary);
     if(isBinary)
     {
       m_Controls->m_JSHistogram->ClearHistogram();
       m_Controls->m_lineRadioButton->setEnabled(true);
       m_Controls->m_barRadioButton->setEnabled(true);
       m_Controls->m_InfoLabel->setText(QString(""));
     }
     for (int i= 0; i< selectedNodes.size(); ++i)
     {
       this->m_SelectedDataNodes.push_back(selectedNodes.at(i));
     }
     this->m_DataNodeSelectionChanged = false;
     this->m_Controls->m_ErrorMessageLabel->setText( "" );
     this->m_Controls->m_ErrorMessageLabel->hide();
     emit StatisticsUpdate();
   }
   else
   {
     this->m_DataNodeSelectionChanged = false;
   }
 }
 
 void QmitkImageStatisticsView::ReinitData()
 {
   while( this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
 
   if(this->m_SelectedImage != NULL)
   {
     this->m_SelectedImage->RemoveObserver( this->m_ImageObserverTag);
     this->m_SelectedImage = NULL;
   }
   if(this->m_SelectedImageMask != NULL)
   {
     this->m_SelectedImageMask->RemoveObserver( this->m_ImageMaskObserverTag);
     this->m_SelectedImageMask = NULL;
   }
   if(this->m_SelectedPlanarFigure != NULL)
   {
     this->m_SelectedPlanarFigure->RemoveObserver( this->m_PlanarFigureObserverTag);
     this->m_SelectedPlanarFigure = NULL;
   }
   this->m_SelectedDataNodes.clear();
   this->m_StatisticsUpdatePending = false;
 
   m_Controls->m_ErrorMessageLabel->setText( "" );
   m_Controls->m_ErrorMessageLabel->hide();
   this->InvalidateStatisticsTableView();
   m_Controls->m_JSHistogram->ClearHistogram();
   m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
 }
 
 void QmitkImageStatisticsView::OnThreadedStatisticsCalculationEnds()
 {
   std::stringstream message;
   message << "";
   m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
   m_Controls->m_ErrorMessageLabel->hide();
   this->WriteStatisticsToGUI();
 }
 
 void QmitkImageStatisticsView::UpdateStatistics()
 {
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   if ( renderPart == NULL )
   {
     this->m_StatisticsUpdatePending =  false;
     return;
   }
   m_WorldMinList.clear();
   m_WorldMaxList.clear();
 
   // classify selected nodes
   mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
 
   std::string maskName = std::string();
   std::string maskType = std::string();
   unsigned int maskDimension = 0;
 
   // reset data from last run
   ITKCommandType::Pointer changeListener = ITKCommandType::New();
   changeListener->SetCallbackFunction( this, &QmitkImageStatisticsView::SelectedDataModified );
 
   mitk::DataNode::Pointer planarFigureNode;
   for( int i= 0 ; i < this->m_SelectedDataNodes.size(); ++i)
   {
     mitk::PlanarFigure::Pointer planarFig = dynamic_cast<mitk::PlanarFigure*>(this->m_SelectedDataNodes.at(i)->GetData());
     if( imagePredicate->CheckNode(this->m_SelectedDataNodes.at(i)) )
     {
       bool isMask = false;
       this->m_SelectedDataNodes.at(i)->GetPropertyValue("binary", isMask);
 
       if( this->m_SelectedImageMask == NULL && isMask)
       {
         this->m_SelectedImageMask = dynamic_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
         this->m_ImageMaskObserverTag = this->m_SelectedImageMask->AddObserver(itk::ModifiedEvent(), changeListener);
 
         maskName = this->m_SelectedDataNodes.at(i)->GetName();
         maskType = m_SelectedImageMask->GetNameOfClass();
         maskDimension = 3;
       }
       else if( !isMask )
       {
         if(this->m_SelectedImage == NULL)
         {
           this->m_SelectedImage = static_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
           this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
         }
       }
     }
     else if (planarFig.IsNotNull())
     {
       if(this->m_SelectedPlanarFigure == NULL)
       {
         this->m_SelectedPlanarFigure = planarFig;
         this->m_PlanarFigureObserverTag  =
           this->m_SelectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
         maskName = this->m_SelectedDataNodes.at(i)->GetName();
         maskType = this->m_SelectedPlanarFigure->GetNameOfClass();
         maskDimension = 2;
         planarFigureNode = m_SelectedDataNodes.at(i);
       }
     }
     else
     {
       std::stringstream message;
       message << "<font color='red'>" << "Invalid data node type!" << "</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
     }
   }
 
   if(maskName == "")
   {
     maskName = "None";
     maskType = "";
     maskDimension = 0;
   }
 
   if (m_SelectedPlanarFigure != NULL && m_SelectedImage == NULL)
   {
     mitk::DataStorage::SetOfObjects::ConstPointer parentSet = this->GetDataStorage()->GetSources(planarFigureNode);
     for (int i=0; i<parentSet->Size(); i++)
     {
       mitk::DataNode::Pointer node = parentSet->ElementAt(i);
       if( imagePredicate->CheckNode(node) )
       {
         bool isMask = false;
         node->GetPropertyValue("binary", isMask);
 
         if( !isMask )
         {
           if(this->m_SelectedImage == NULL)
           {
             this->m_SelectedImage = static_cast<mitk::Image*>(node->GetData());
             this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
           }
         }
       }
     }
   }
 
   unsigned int timeStep = renderPart->GetTimeNavigationController()->GetTime()->GetPos();
 
   if ( m_SelectedImage != NULL && m_SelectedImage->IsInitialized())
   {
     // Check if a the selected image is a multi-channel image. If yes, statistics
     // cannot be calculated currently.
     if ( m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
     {
       std::stringstream message;
       message << "<font color='red'>Multi-component images not supported.</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
 
       this->InvalidateStatisticsTableView();
       m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
       m_Controls->m_JSHistogram->ClearHistogram();
       m_CurrentStatisticsValid = false;
       this->m_StatisticsUpdatePending = false;
       m_Controls->m_lineRadioButton->setEnabled(true);
       m_Controls->m_barRadioButton->setEnabled(true);
       m_Controls->m_InfoLabel->setText(QString(""));
       return;
     }
 
     std::stringstream maskLabel;
     maskLabel << maskName;
     if ( maskDimension > 0 )
     {
       maskLabel << "  [" << maskDimension << "D " << maskType << "]";
     }
     m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
 
     // check time step validity
     if(m_SelectedImage->GetDimension() <= 3 && timeStep > m_SelectedImage->GetDimension(3)-1)
     {
       timeStep = m_SelectedImage->GetDimension(3)-1;
     }
 
     // Add the used mask time step to the mask label so the user knows which mask time step was used
     // if the image time step is bigger than the total number of mask time steps (see
     // ImageStatisticsCalculator::ExtractImageAndMask)
     if (m_SelectedImageMask != NULL)
     {
       unsigned int maskTimeStep = timeStep;
 
       if (maskTimeStep >= m_SelectedImageMask->GetTimeSteps())
       {
         maskTimeStep = m_SelectedImageMask->GetTimeSteps() - 1;
       }
 
       m_Controls->m_SelectedMaskLabel->setText(m_Controls->m_SelectedMaskLabel->text() +
                                                QString(" (t=") +
                                                QString::number(maskTimeStep) +
                                                QString(")"));
     }
 
     //// initialize thread and trigger it
     this->m_CalculationThread->SetIgnoreZeroValueVoxel( m_Controls->m_IgnoreZerosCheckbox->isChecked() );
     this->m_CalculationThread->Initialize( m_SelectedImage, m_SelectedImageMask, m_SelectedPlanarFigure );
     this->m_CalculationThread->SetTimeStep( timeStep );
     std::stringstream message;
     message << "<font color='red'>Calculating statistics...</font>";
     m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
     m_Controls->m_ErrorMessageLabel->show();
 
     try
     {
       // Compute statistics
       this->m_CalculationThread->start();
     }
     catch ( const mitk::Exception& e)
     {
       std::stringstream message;
       message << "<font color='red'>" << e.GetDescription() << "</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
     catch ( const std::runtime_error &e )
     {
       // In case of exception, print error message on GUI
       std::stringstream message;
       message << "<font color='red'>" << e.what() << "</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
     catch ( const std::exception &e )
     {
       MITK_ERROR << "Caught exception: " << e.what();
 
       // In case of exception, print error message on GUI
       std::stringstream message;
       message << "<font color='red'>Error! Unequal Dimensions of Image and Segmentation. No recompute possible </font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
   }
   else
   {
     this->m_StatisticsUpdatePending = false;
   }
 }
 
 void QmitkImageStatisticsView::SelectedDataModified()
 {
   if( !m_StatisticsUpdatePending )
   {
     emit StatisticsUpdate();
   }
 }
 
 void QmitkImageStatisticsView::NodeRemoved(const mitk::DataNode *node)
 {
   while(this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
 
   if (node->GetData() == m_SelectedImage)
   {
     m_SelectedImage = NULL;
   }
 }
 
 void QmitkImageStatisticsView::RequestStatisticsUpdate()
 {
   if ( !m_StatisticsUpdatePending )
   {
     if(this->m_DataNodeSelectionChanged)
     {
       this->SelectionChanged(this->GetCurrentSelection());
     }
     else
     {
       this->m_StatisticsUpdatePending = true;
       this->UpdateStatistics();
     }
   }
   if (this->GetRenderWindowPart())
     this->GetRenderWindowPart()->RequestUpdate();
 }
 
 void QmitkImageStatisticsView::WriteStatisticsToGUI()
 {
   m_Controls->m_lineRadioButton->setEnabled(true);
   m_Controls->m_barRadioButton->setEnabled(true);
   m_Controls->m_InfoLabel->setText(QString(""));
 
   if(m_DataNodeSelectionChanged)
   {
     this->m_StatisticsUpdatePending = false;
     this->RequestStatisticsUpdate();
     return;    // stop visualization of results and calculate statistics of new selection
   }
 
   if ( this->m_CalculationThread->GetStatisticsUpdateSuccessFlag())
   {
     if ( this->m_CalculationThread->GetStatisticsChangedFlag() )
     {
       // Do not show any error messages
       m_Controls->m_ErrorMessageLabel->hide();
       m_CurrentStatisticsValid = true;
     }
 
     if (m_Controls->m_barRadioButton->isChecked())
     {
       m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
     }
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
     //m_Controls->m_JSHistogram->ComputeHistogram( this->m_CalculationThread->GetTimeStepHistogram(this->m_CalculationThread->GetTimeStep()).GetPointer() );
     this->FillStatisticsTableView( this->m_CalculationThread->GetStatisticsData(), this->m_CalculationThread->GetStatisticsImage());
   }
   else
   {
     m_Controls->m_SelectedMaskLabel->setText( "None" );
     m_Controls->m_ErrorMessageLabel->setText( m_CalculationThread->GetLastErrorMessage().c_str() );
     m_Controls->m_ErrorMessageLabel->show();
     // Clear statistics and histogram
     this->InvalidateStatisticsTableView();
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
     //m_Controls->m_JSHistogram->clearHistogram();
     m_CurrentStatisticsValid = false;
 
     // If a (non-closed) PlanarFigure is selected, display a line profile widget
     if ( m_SelectedPlanarFigure != NULL )
     {
       // Check if the (closed) planar figure is out of bounds and so no image mask could be calculated--> Intensity Profile can not be calculated
       bool outOfBounds = false;
       if ( m_SelectedPlanarFigure->IsClosed() && m_SelectedImageMask == NULL)
       {
         outOfBounds = true;
         std::stringstream message;
         message << "<font color='red'>Planar figure is outside the images bounds.</font>";
         m_Controls->m_InfoLabel->setText(message.str().c_str());
       }
 
       // check whether PlanarFigure is initialized
-      const mitk::PlaneGeometry *planarFigureGeometry2D = m_SelectedPlanarFigure->GetGeometry2D();
-      if ( planarFigureGeometry2D == NULL || outOfBounds)
+      const mitk::PlaneGeometry *planarFigurePlaneGeometry = m_SelectedPlanarFigure->GetPlaneGeometry();
+      if ( planarFigurePlaneGeometry == NULL || outOfBounds)
       {
         // Clear statistics, histogram, and GUI
         this->InvalidateStatisticsTableView();
         m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
         m_Controls->m_JSHistogram->ClearHistogram();
         m_CurrentStatisticsValid = false;
         m_Controls->m_ErrorMessageLabel->hide();
         m_Controls->m_SelectedMaskLabel->setText( "None" );
         this->m_StatisticsUpdatePending = false;
         m_Controls->m_lineRadioButton->setEnabled(true);
         m_Controls->m_barRadioButton->setEnabled(true);
         if (!outOfBounds)
           m_Controls->m_InfoLabel->setText(QString(""));
         return;
       }
       unsigned int timeStep = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
       m_Controls->m_JSHistogram->SetImage(this->m_CalculationThread->GetStatisticsImage());
       m_Controls->m_JSHistogram->SetPlanarFigure(m_SelectedPlanarFigure);
       m_Controls->m_JSHistogram->ComputeIntensityProfile(timeStep);
       m_Controls->m_lineRadioButton->setEnabled(false);
       m_Controls->m_barRadioButton->setEnabled(false);
       std::stringstream message;
       message << "<font color='red'>Only linegraph available for an intesityprofile!</font>";
       m_Controls->m_InfoLabel->setText(message.str().c_str());
     }
   }
   this->m_StatisticsUpdatePending = false;
 }
 
 void QmitkImageStatisticsView::FillStatisticsTableView(
   const std::vector<mitk::ImageStatisticsCalculator::Statistics> &s,
   const mitk::Image *image )
 {
   this->m_Controls->m_StatisticsTable->setColumnCount(image->GetTimeSteps());
   this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(image->GetTimeSteps() > 1);
 
   for (unsigned int t = 0; t < image->GetTimeSteps(); t++)
   {
     this->m_Controls->m_StatisticsTable->setHorizontalHeaderItem(t,
       new QTableWidgetItem(QString::number(t)));
 
     if (s[t].MaxIndex.size()==3)
     {
       mitk::Point3D index, max, min;
       index[0] = s[t].MaxIndex[0];
       index[1] = s[t].MaxIndex[1];
       index[2] = s[t].MaxIndex[2];
       m_SelectedImage->GetGeometry()->IndexToWorld(index, max);
       this->m_WorldMaxList.push_back(max);
       index[0] = s[t].MinIndex[0];
       index[1] = s[t].MinIndex[1];
       index[2] = s[t].MinIndex[2];
       m_SelectedImage->GetGeometry()->IndexToWorld(index, min);
       this->m_WorldMinList.push_back(min);
     }
 
     int decimals = 2;
 
     mitk::PixelType doublePix = mitk::MakeScalarPixelType< double >();
     mitk::PixelType floatPix = mitk::MakeScalarPixelType< float >();
     if (image->GetPixelType()==doublePix || image->GetPixelType()==floatPix)
       decimals = 5;
 
     this->m_Controls->m_StatisticsTable->setItem( 0, t, new QTableWidgetItem(
       QString("%1").arg(s[t].Mean, 0, 'f', decimals) ) );
     this->m_Controls->m_StatisticsTable->setItem( 1, t, new QTableWidgetItem(
       QString("%1").arg(s[t].Sigma, 0, 'f', decimals) ) );
 
     this->m_Controls->m_StatisticsTable->setItem( 2, t, new QTableWidgetItem(
       QString("%1").arg(s[t].RMS, 0, 'f', decimals) ) );
 
     QString max; max.append(QString("%1").arg(s[t].Max, 0, 'f', decimals));
     max += " (";
     for (int i=0; i<s[t].MaxIndex.size(); i++)
     {
       max += QString::number(s[t].MaxIndex[i]);
       if (i<s[t].MaxIndex.size()-1)
         max += ",";
     }
     max += ")";
     this->m_Controls->m_StatisticsTable->setItem( 3, t, new QTableWidgetItem( max ) );
 
     QString min; min.append(QString("%1").arg(s[t].Min, 0, 'f', decimals));
     min += " (";
     for (int i=0; i<s[t].MinIndex.size(); i++)
     {
       min += QString::number(s[t].MinIndex[i]);
       if (i<s[t].MinIndex.size()-1)
         min += ",";
     }
     min += ")";
     this->m_Controls->m_StatisticsTable->setItem( 4, t, new QTableWidgetItem( min ) );
 
     this->m_Controls->m_StatisticsTable->setItem( 5, t, new QTableWidgetItem(
       QString("%1").arg(s[t].N) ) );
 
     const mitk::BaseGeometry *geometry = image->GetGeometry();
     if ( geometry != NULL )
     {
       const mitk::Vector3D &spacing = image->GetGeometry()->GetSpacing();
       double volume = spacing[0] * spacing[1] * spacing[2] * (double) s[t].N;
       this->m_Controls->m_StatisticsTable->setItem( 6, t, new QTableWidgetItem(
         QString("%1").arg(volume, 0, 'f', decimals) ) );
     }
     else
     {
       this->m_Controls->m_StatisticsTable->setItem( 6, t, new QTableWidgetItem(
         "NA" ) );
     }
   }
 
   this->m_Controls->m_StatisticsTable->resizeColumnsToContents();
   int height = STAT_TABLE_BASE_HEIGHT;
 
   if (this->m_Controls->m_StatisticsTable->horizontalHeader()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalHeader()->height();
 
   if (this->m_Controls->m_StatisticsTable->horizontalScrollBar()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalScrollBar()->height();
 
   this->m_Controls->m_StatisticsTable->setMinimumHeight(height);
 
   // make sure the current timestep's column is highlighted (and the correct histogram is displayed)
   unsigned int timestep = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
     GetPos();
   mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(),
     timestep);
   this->OnTimeChanged(timeEvent);
 }
 
 void QmitkImageStatisticsView::InvalidateStatisticsTableView()
 {
   this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(false);
   this->m_Controls->m_StatisticsTable->setColumnCount(1);
 
   for ( unsigned int i = 0; i < this->m_Controls->m_StatisticsTable->rowCount(); ++i )
   {
     {
       this->m_Controls->m_StatisticsTable->setItem( i, 0, new QTableWidgetItem( "NA" ) );
     }
   }
 
   this->m_Controls->m_StatisticsTable->setMinimumHeight(STAT_TABLE_BASE_HEIGHT);
 }
 
 void QmitkImageStatisticsView::Activated()
 {
 }
 
 void QmitkImageStatisticsView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsView::Visible()
 {
   m_Visible = true;
 
   mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
 
   if (renderWindow)
   {
     itk::ReceptorMemberCommand<QmitkImageStatisticsView>::Pointer cmdTimeEvent =
       itk::ReceptorMemberCommand<QmitkImageStatisticsView>::New();
     cmdTimeEvent->SetCallbackFunction(this, &QmitkImageStatisticsView::OnTimeChanged);
 
     // It is sufficient to add the observer to the axial render window since the GeometryTimeEvent
     // is always triggered by all views.
     m_TimeObserverTag = renderWindow->GetQmitkRenderWindow("axial")->
       GetSliceNavigationController()->
       AddObserver(mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), cmdTimeEvent);
   }
 
 
 
   if (m_DataNodeSelectionChanged)
   {
     if (this->IsCurrentSelectionValid())
     {
       this->SelectionChanged(this->GetCurrentSelection());
     }
     else
     {
       this->SelectionChanged(this->GetDataManagerSelection());
     }
     m_DataNodeSelectionChanged = false;
   }
 }
 
 void QmitkImageStatisticsView::Hidden()
 {
   m_Visible = false;
 
   // The slice navigation controller observer is removed here instead of in the destructor.
   // If it was called in the destructor, the application would freeze because the view's
   // destructor gets called after the render windows have been destructed.
   if ( m_TimeObserverTag != NULL )
   {
     mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
 
     if (renderWindow)
     {
       renderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->
         RemoveObserver( m_TimeObserverTag );
     }
     m_TimeObserverTag = NULL;
   }
 
 }
 
 void QmitkImageStatisticsView::SetFocus()
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
index bfffdcf0fd..7830406f1a 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,911 +1,911 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define MEASUREMENT_DEBUG MITK_DEBUG("QmitkMeasurementView") << __LINE__ << ": "
 
 #include "QmitkMeasurementView.h"
 
 #include <QtGui>
 
 #include <mitkIPropertyFilters.h>
 #include <mitkPropertyFilter.h>
 #include <mitkVtkLayerController.h>
 #include <mitkWeakPointer.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarAngle.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarLine.h>
 #include <mitkPlanarCross.h>
 #include <mitkPlanarFourPointAngle.h>
 #include <mitkPlanarDoubleEllipse.h>
 #include <mitkPlanarBezierCurve.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <QmitkRenderWindow.h>
 
 #include "mitkPluginActivator.h"
 #include "usModuleRegistry.h"
 
 template <class T>
 static T* GetService()
 {
   ctkPluginContext* context = mitk::PluginActivator::GetContext();
   ctkServiceReference serviceRef = context->getServiceReference<T>();
 
   return serviceRef
     ? context->getService<T>(serviceRef)
     : NULL;
 }
 
 struct QmitkPlanarFigureData
 {
   QmitkPlanarFigureData()
     : m_Figure(0), m_EndPlacementObserverTag(0), m_SelectObserverTag(0), m_StartInteractionObserverTag(0), m_EndInteractionObserverTag(0)
   {
   }
 
   mitk::PlanarFigure* m_Figure;
   unsigned int m_EndPlacementObserverTag;
   unsigned int m_SelectObserverTag;
   unsigned int m_StartInteractionObserverTag;
   unsigned int m_EndInteractionObserverTag;
 };
 
 struct QmitkMeasurementViewData
 {
   QmitkMeasurementViewData()
     : m_LineCounter(0), m_PathCounter(0), m_AngleCounter(0),
       m_FourPointAngleCounter(0), m_EllipseCounter(0), m_DoubleEllipseCounter(0),
       m_RectangleCounter(0), m_PolygonCounter(0), m_BezierCurveCounter(0),
       m_UnintializedPlanarFigure(false)
   {
   }
 
   // internal vars
   unsigned int m_LineCounter;
   unsigned int m_PathCounter;
   unsigned int m_AngleCounter;
   unsigned int m_FourPointAngleCounter;
   unsigned int m_EllipseCounter;
   unsigned int m_DoubleEllipseCounter;
   unsigned int m_RectangleCounter;
   unsigned int m_PolygonCounter;
   unsigned int m_BezierCurveCounter;
   QList<mitk::DataNode::Pointer> m_CurrentSelection;
   std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData;
   mitk::WeakPointer<mitk::DataNode> m_SelectedImageNode;
   bool m_UnintializedPlanarFigure;
 
   // WIDGETS
   QWidget* m_Parent;
   QLabel* m_SelectedImageLabel;
   QAction* m_DrawLine;
   QAction* m_DrawPath;
   QAction* m_DrawAngle;
   QAction* m_DrawFourPointAngle;
   QAction* m_DrawDoubleEllipse;
   QAction* m_DrawRectangle;
   QAction* m_DrawPolygon;
   QAction* m_DrawEllipse;
   QAction* m_DrawBezierCurve;
   QToolBar* m_DrawActionsToolBar;
   QActionGroup* m_DrawActionsGroup;
   QTextBrowser* m_SelectedPlanarFiguresText;
   QPushButton* m_CopyToClipboard;
   QGridLayout* m_Layout;
 };
 
 const std::string QmitkMeasurementView::VIEW_ID = "org.mitk.views.measurement";
 
 QmitkMeasurementView::QmitkMeasurementView()
   : d( new QmitkMeasurementViewData )
 {
 }
 QmitkMeasurementView::~QmitkMeasurementView()
 {
   this->RemoveAllInteractors();
   delete d;
 }
 void QmitkMeasurementView::CreateQtPartControl(QWidget* parent)
 {
   d->m_Parent = parent;
 
   // image label
   QLabel* selectedImageLabel = new QLabel("Reference Image: ");
   d->m_SelectedImageLabel = new QLabel;
   d->m_SelectedImageLabel->setStyleSheet("font-weight: bold;");
 
   d->m_DrawActionsToolBar = new QToolBar;
   d->m_DrawActionsGroup = new QActionGroup(this);
   d->m_DrawActionsGroup->setExclusive(true);
 
   //# add actions
   MEASUREMENT_DEBUG << "Draw Line";
   QAction* currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/line.png"), "Draw Line");
   currentAction->setCheckable(true);
   d->m_DrawLine = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Path";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/path.png"), "Draw Path");
   currentAction->setCheckable(true);
   d->m_DrawPath = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/angle.png"), "Draw Angle");
   currentAction->setCheckable(true);
   d->m_DrawAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Four Point Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/four-point-angle.png"), "Draw Four Point Angle");
   currentAction->setCheckable(true);
   d->m_DrawFourPointAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Circle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/circle.png"), "Draw Circle");
   currentAction->setCheckable(true);
   d->m_DrawEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Rectangle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/rectangle.png"), "Draw Rectangle");
   currentAction->setCheckable(true);
   d->m_DrawRectangle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Polygon";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/polygon.png"), "Draw Polygon");
   currentAction->setCheckable(true);
   d->m_DrawPolygon = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Double Ellipse";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/doubleellipse.png"), "Draw Double Ellipse");
   currentAction->setCheckable(true);
   d->m_DrawDoubleEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Bezier Curve";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/beziercurve.png"), "Draw Bezier Curve");
   currentAction->setCheckable(true);
   d->m_DrawBezierCurve = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   // planar figure details text
   d->m_SelectedPlanarFiguresText = new QTextBrowser;
 
   // copy to clipboard button
   d->m_CopyToClipboard = new QPushButton("Copy to Clipboard");
 
   d->m_Layout = new QGridLayout;
   d->m_Layout->addWidget(selectedImageLabel, 0, 0, 1, 1);
   d->m_Layout->addWidget(d->m_SelectedImageLabel, 0, 1, 1, 1);
   d->m_Layout->addWidget(d->m_DrawActionsToolBar, 1, 0, 1, 2);
   d->m_Layout->addWidget(d->m_SelectedPlanarFiguresText, 2, 0, 1, 2);
   d->m_Layout->addWidget(d->m_CopyToClipboard, 3, 0, 1, 2);
 
   d->m_Parent->setLayout(d->m_Layout);
 
   // create connections
   this->CreateConnections();
 
   // readd interactors and observers
   this->AddAllInteractors();
 }
 void QmitkMeasurementView::CreateConnections()
 {
   QObject::connect( d->m_DrawLine, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawLineTriggered(bool) ) );
   QObject::connect( d->m_DrawPath, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawPathTriggered(bool) ) );
   QObject::connect( d->m_DrawAngle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawFourPointAngle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawFourPointAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawEllipse, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawDoubleEllipse, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawDoubleEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawRectangle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawRectangleTriggered(bool) ) );
   QObject::connect( d->m_DrawPolygon, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawPolygonTriggered(bool) ) );
   QObject::connect( d->m_DrawBezierCurve, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawBezierCurveTriggered(bool) ) );
   QObject::connect( d->m_CopyToClipboard, SIGNAL( clicked(bool) ), this, SLOT( CopyToClipboard(bool) ) );
 }
 
 void QmitkMeasurementView::NodeAdded( const mitk::DataNode* node )
 {
   // add observer for selection in renderwindow
   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
   bool isPositionMarker (false);
   node->GetBoolProperty("isContourMarker", isPositionMarker);
   if( figure && !isPositionMarker )
   {
     MEASUREMENT_DEBUG << "figure added. will add interactor if needed.";
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer() );
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( nonConstNode );
       //      nonConstNode->SetBoolProperty( "planarfigure.isextendable", true );
     }
     else
     {
       // just to be sure that the interactor is not added twice
       //    mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
     }
 
     MEASUREMENT_DEBUG << "adding interactor to globalinteraction";
     //  mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
 
     MEASUREMENT_DEBUG << "will now add observers for planarfigure";
     QmitkPlanarFigureData data;
     data.m_Figure = figure;
 
     // add observer for event when figure has been placed
     typedef itk::SimpleMemberCommand< QmitkMeasurementView > SimpleCommandType;
     SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
     initializationCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureInitialized );
     data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
     // add observer for event when figure is picked (selected)
     typedef itk::MemberCommand< QmitkMeasurementView > MemberCommandType;
     MemberCommandType::Pointer selectCommand = MemberCommandType::New();
     selectCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureSelected );
     data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
     startInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::DisableCrosshairNavigation);
     data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
     endInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::EnableCrosshairNavigation);
     data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
     // adding to the map of tracked planarfigures
     d->m_DataNodeToPlanarFigureData[nonConstNode] = data;
   }
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::NodeChanged(const mitk::DataNode* node)
 {
   // DETERMINE IF WE HAVE TO RENEW OUR DETAILS TEXT (ANY NODE CHANGED IN OUR SELECTION?)
   bool renewText = false;
   for( int i=0; i < d->m_CurrentSelection.size(); ++i )
   {
     if( node == d->m_CurrentSelection.at(i) )
     {
       renewText = true;
       break;
     }
   }
 
   if(renewText)
   {
     MEASUREMENT_DEBUG << "Selected nodes changed. Refreshing text.";
     this->UpdateMeasurementText();
   }
 
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::CheckForTopMostVisibleImage(mitk::DataNode* _NodeToNeglect)
 {
   d->m_SelectedImageNode = this->DetectTopMostVisibleImage().GetPointer();
   if( d->m_SelectedImageNode.GetPointer() == _NodeToNeglect )
     d->m_SelectedImageNode = 0;
 
   if( d->m_SelectedImageNode.IsNotNull() && d->m_UnintializedPlanarFigure == false )
   {
     MEASUREMENT_DEBUG << "Reference image found";
     d->m_SelectedImageLabel->setText( QString::fromStdString( d->m_SelectedImageNode->GetName() ) );
     d->m_DrawActionsToolBar->setEnabled(true);
     MEASUREMENT_DEBUG << "Updating Measurement text";
   }
   else
   {
     MEASUREMENT_DEBUG << "No reference image available. Will disable actions for creating new planarfigures";
     if( d->m_UnintializedPlanarFigure == false )
       d->m_SelectedImageLabel->setText( "No visible image available." );
 
     d->m_DrawActionsToolBar->setEnabled(false);
   }
 }
 
 void QmitkMeasurementView::NodeRemoved(const mitk::DataNode* node)
 {
   MEASUREMENT_DEBUG << "node removed from data storage";
 
   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.find(nonConstNode);
 
   bool isFigureFinished = false;
   bool isPlaced = false;
 
   if( it != d->m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
     // remove observers
     data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
     data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
     data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
     data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
     MEASUREMENT_DEBUG << "removing from the list of tracked planar figures";
 
     isFigureFinished = data.m_Figure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
     if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
       PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
     }
     d->m_DataNodeToPlanarFigureData.erase( it );
   }
 
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes =
       GetDataStorage()->GetDerivations(node,isPlanarFigure);
 
   for (unsigned int x = 0; x < nodes->size(); x++)
   {
     mitk::PlanarFigure* planarFigure  = dynamic_cast<mitk::PlanarFigure*>  (nodes->at(x)->GetData());
     if (planarFigure != NULL) {
 
       isFigureFinished = planarFigure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
       if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
         GetDataStorage()->Remove(nodes->at(x));
         if( !d->m_DataNodeToPlanarFigureData.empty() )
         {
           std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it2 =
               d->m_DataNodeToPlanarFigureData.find(nodes->at(x));
           //check if returned it2 valid
           if( it2 != d->m_DataNodeToPlanarFigureData.end() )
           {
             d->m_DataNodeToPlanarFigureData.erase( it2 );// removing planar figure from tracked figure list
             PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
             EnableCrosshairNavigation();
           }
         }
       }
     }
   }
   this->CheckForTopMostVisibleImage(nonConstNode);
 }
 
 
 void QmitkMeasurementView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
   MEASUREMENT_DEBUG << "planar figure " << object << " selected";
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.begin();
 
   d->m_CurrentSelection.clear();
   while( it != d->m_DataNodeToPlanarFigureData.end())
   {
     mitk::DataNode* node = it->first;
     QmitkPlanarFigureData& data = it->second;
 
     if( data.m_Figure == object )
     {
       MITK_DEBUG << "selected node found. enabling selection";
       node->SetSelected(true);
       d->m_CurrentSelection.push_back( node );
     }
     else
     {
       node->SetSelected(false);
     }
 
     ++it;
   }
   this->UpdateMeasurementText();
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::PlanarFigureInitialized()
 {
   MEASUREMENT_DEBUG << "planar figure initialized";
   d->m_UnintializedPlanarFigure = false;
   d->m_DrawActionsToolBar->setEnabled(true);
 
   d->m_DrawLine->setChecked(false);
   d->m_DrawPath->setChecked(false);
   d->m_DrawAngle->setChecked(false);
   d->m_DrawFourPointAngle->setChecked(false);
   d->m_DrawEllipse->setChecked(false);
   d->m_DrawRectangle->setChecked(false);
   d->m_DrawPolygon->setChecked(false);
   d->m_DrawDoubleEllipse->setChecked(false);
   d->m_DrawBezierCurve->setChecked(false);
 }
 
 void QmitkMeasurementView::SetFocus()
 {
   d->m_SelectedImageLabel->setFocus();
 }
 
 void QmitkMeasurementView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                               const QList<mitk::DataNode::Pointer> &nodes)
 {
   MEASUREMENT_DEBUG << "Determine the top most visible image";
   MEASUREMENT_DEBUG << "The PlanarFigure interactor will take the currently visible PlaneGeometry from the slice navigation controller";
 
   this->CheckForTopMostVisibleImage();
 
   MEASUREMENT_DEBUG << "refreshing selection and detailed text";
   d->m_CurrentSelection = nodes;
   this->UpdateMeasurementText();
   // bug 16600: deselecting all planarfigures by clicking on datamanager when no node is selected
   if(d->m_CurrentSelection.size() == 0)
   {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
     mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetDataStorage()->GetSubset( isPlanarFigure );
     // setting all planar figures which are not helper objects not selected
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin(); it!=planarFigures->End(); it++)
     {
       mitk::DataNode* node = it.Value();
       bool isHelperObject(false);
       node->GetBoolProperty("helper object", isHelperObject);
       if(!isHelperObject)
       {
         node->SetSelected(false);
       }
     }
   }
 
   for( int i=d->m_CurrentSelection.size()-1; i>= 0; --i)
   {
     mitk::DataNode* node = d->m_CurrentSelection.at(i);
     mitk::PlanarFigure* _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     // the last selected planar figure
 
-    if (_PlanarFigure && _PlanarFigure->GetGeometry2D())
+    if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       mitk::ILinkedRenderWindowPart* linkedRenderWindow = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
       if(! linkedRenderWindow )
       {
         return;
       }
 
       QmitkRenderWindow* RenderWindow1 = linkedRenderWindow->GetQmitkRenderWindow( "axial") ;
       QmitkRenderWindow* RenderWindow2 = linkedRenderWindow->GetQmitkRenderWindow( "sagittal") ;
       QmitkRenderWindow* RenderWindow3 = linkedRenderWindow->GetQmitkRenderWindow( "coronal") ;
       QmitkRenderWindow* RenderWindow4 = linkedRenderWindow->GetQmitkRenderWindow( "3d") ;
 
       if (node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
-      const mitk::PlaneGeometry* _PlaneGeometry = dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
+      const mitk::PlaneGeometry* _PlaneGeometry = dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetPlaneGeometry());
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
-      mitk::PlaneGeometry::ConstPointer _Plane1 = RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
+      mitk::PlaneGeometry::ConstPointer _Plane1 = RenderWindow1->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
-      mitk::PlaneGeometry::ConstPointer _Plane2 = RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
+      mitk::PlaneGeometry::ConstPointer _Plane2 = RenderWindow2->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
-      mitk::PlaneGeometry::ConstPointer _Plane3 = RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
+      mitk::PlaneGeometry::ConstPointer _Plane3 = RenderWindow3->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = RenderWindow1;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = RenderWindow2;
         }
         else
         {
           selectedRenderWindow = RenderWindow3;
         }
       }
 
       // re-orient view
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(centerP, _PlaneGeometry->GetNormal());
       }
     }
     break;
   }
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::ActionDrawLineTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarLine::Pointer figure = mitk::PlanarLine::New();
   QString qString = QString("Line%1").arg(++d->m_LineCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarLine initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPathTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::IPropertyFilters* propertyFilters = GetService<mitk::IPropertyFilters>();
 
   if (propertyFilters != NULL)
   {
     mitk::PropertyFilter filter;
     filter.AddEntry("ClosedPlanarPolygon", mitk::PropertyFilter::Blacklist);
 
     propertyFilters->AddFilter(filter, "PlanarPolygon");
   }
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOff();
   QString qString = QString("Path%1").arg(++d->m_PathCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   mitk::BoolProperty::Pointer closedProperty = mitk::BoolProperty::New( false );
   node->SetProperty("ClosedPlanarPolygon", closedProperty);
   node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
 
   MEASUREMENT_DEBUG << "PlanarPath initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarAngle::Pointer figure = mitk::PlanarAngle::New();
   QString qString = QString("Angle%1").arg(++d->m_AngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawFourPointAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarFourPointAngle::Pointer figure =
       mitk::PlanarFourPointAngle::New();
   QString qString = QString("Four Point Angle%1").arg(++d->m_FourPointAngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarFourPointAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   QString qString = QString("Circle%1").arg(++d->m_EllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarCircle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawDoubleEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarDoubleEllipse::Pointer figure = mitk::PlanarDoubleEllipse::New();
   QString qString = QString("DoubleEllipse%1").arg(++d->m_DoubleEllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarDoubleEllipse initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawBezierCurveTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarBezierCurve::Pointer figure = mitk::PlanarBezierCurve::New();
   QString qString = QString("BezierCurve%1").arg(++d->m_BezierCurveCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarBezierCurve initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawRectangleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
   QString qString = QString("Rectangle%1").arg(++d->m_RectangleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarRectangle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPolygonTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOn();
   QString qString = QString("Polygon%1").arg(++d->m_PolygonCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
 
   MEASUREMENT_DEBUG << "PlanarPolygon initialized...";
 }
 
 void QmitkMeasurementView::CopyToClipboard( bool checked )
 {
   Q_UNUSED(checked)
 
   MEASUREMENT_DEBUG << "Copying current Text to clipboard...";
   QString clipboardText = d->m_SelectedPlanarFiguresText->toPlainText();
   QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::AddFigureToDataStorage(
     mitk::PlanarFigure* figure, const QString& name)
 {
   // add as
   MEASUREMENT_DEBUG << "Adding new figure to datastorage...";
   if( d->m_SelectedImageNode.IsNull() )
   {
     MITK_ERROR << "No reference image available";
     return 0;
   }
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(name.toStdString());
   newNode->SetData(figure);
   // set as selected
   newNode->SetSelected( true );
   this->GetDataStorage()->Add(newNode, d->m_SelectedImageNode);
 
   // set all others in selection as deselected
   for( int i=0; i<d->m_CurrentSelection.size(); ++i)
     d->m_CurrentSelection.at(i)->SetSelected(false);
   d->m_CurrentSelection.clear();
   d->m_CurrentSelection.push_back( newNode );
   this->UpdateMeasurementText();
   this->DisableCrosshairNavigation();
   d->m_DrawActionsToolBar->setEnabled(false);
   d->m_UnintializedPlanarFigure = true;
   return newNode;
 }
 
 void QmitkMeasurementView::UpdateMeasurementText()
 {
   d->m_SelectedPlanarFiguresText->clear();
 
   QString infoText;
   QString plainInfoText;
   int j = 1;
   mitk::PlanarFigure* _PlanarFigure = 0;
   mitk::PlanarAngle* planarAngle = 0;
   mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
   mitk::DataNode::Pointer node = 0;
 
   for (int i=0; i<d->m_CurrentSelection.size(); ++i, ++j)
   {
     plainInfoText.clear();
     node = d->m_CurrentSelection.at(i);
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if( !_PlanarFigure )
       continue;
 
     if(j>1)
       infoText.append("<br />");
 
     infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(
                                                      node->GetName())));
     plainInfoText.append(QString("%1").arg(QString::fromStdString(
                                              node->GetName())));
 
     planarAngle = dynamic_cast<mitk::PlanarAngle*> (_PlanarFigure);
     if(!planarAngle)
     {
       planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (_PlanarFigure);
     }
 
     double featureQuantity = 0.0;
     for (unsigned int k = 0; k < _PlanarFigure->GetNumberOfFeatures(); ++k)
     {
       if ( !_PlanarFigure->IsFeatureActive( k ) ) continue;
 
       featureQuantity = _PlanarFigure->GetQuantity(k);
       if ((planarAngle && k == planarAngle->FEATURE_ID_ANGLE)
           || (planarFourPointAngle && k == planarFourPointAngle->FEATURE_ID_ANGLE))
         featureQuantity = featureQuantity * 180 / vnl_math::pi;
 
       infoText.append(
             QString("<i>%1</i>: %2 %3") .arg(QString(
                                                _PlanarFigure->GetFeatureName(k))) .arg(featureQuantity, 0, 'f',
                                                                                        2) .arg(QString(_PlanarFigure->GetFeatureUnit(k))));
 
       plainInfoText.append(
             QString("\n%1: %2 %3") .arg(QString(_PlanarFigure->GetFeatureName(k))) .arg(
               featureQuantity, 0, 'f', 2) .arg(QString(
                                                  _PlanarFigure->GetFeatureUnit(k))));
 
       if(k+1 != _PlanarFigure->GetNumberOfFeatures())
         infoText.append("<br />");
     }
 
     if (j != d->m_CurrentSelection.size())
       infoText.append("<br />");
   }
 
   d->m_SelectedPlanarFiguresText->setHtml(infoText);
 }
 
 void QmitkMeasurementView::AddAllInteractors()
 {
   MEASUREMENT_DEBUG << "Adding interactors and observers to all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetAllPlanarFigures();
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin();
     it!=planarFigures->End(); it++)
   {
     this->NodeAdded( it.Value() );
   }
 }
 
 void QmitkMeasurementView::RemoveAllInteractors()
 {
   MEASUREMENT_DEBUG << "Removing interactors and observers from all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetAllPlanarFigures();
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin();
     it!=planarFigures->End(); it++)
   {
     this->NodeRemoved( it.Value() );
   }
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::DetectTopMostVisibleImage()
 {
   // get all images from the data storage which are not a segmentation
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
   mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
 
   mitk::DataStorage::SetOfObjects::ConstPointer Images
       = this->GetDataStorage()->GetSubset( isNormalImage );
 
 
   mitk::DataNode::Pointer currentNode;
   int maxLayer = itk::NumericTraits<int>::min();
 
   // iterate over selection
   for (mitk::DataStorage::SetOfObjects::ConstIterator sofIt = Images->Begin(); sofIt != Images->End(); ++sofIt)
   {
     mitk::DataNode::Pointer node = sofIt->Value();
     if ( node.IsNull() )
       continue;
     if (node->IsVisible(NULL) == false)
       continue;
     // we also do not want to assign planar figures to helper objects ( even if they are of type image )
     if (node->GetProperty("helper object"))
       continue;
 
     int layer = 0;
     node->GetIntProperty("layer", layer);
     if ( layer < maxLayer )
     {
       continue;
     }
     else
     {
       maxLayer = layer;
       currentNode = node;
     }
   }
 
   return currentNode;
 }
 
 void QmitkMeasurementView::EnableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "EnableCrosshairNavigation";
 
   // enable the crosshair navigation
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "enabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(true);
     linkedRenderWindow->EnableSlicingPlanes(true);
   }
 }
 
 void QmitkMeasurementView::DisableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "DisableCrosshairNavigation";
 
   // disable the crosshair navigation during the drawing
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "disabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(false);
     linkedRenderWindow->EnableSlicingPlanes(false);
   }
 }
 
 mitk::DataStorage::SetOfObjects::ConstPointer QmitkMeasurementView::GetAllPlanarFigures() const
 {
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::NodePredicateProperty::Pointer isNotHelperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(false));
   mitk::NodePredicateAnd::Pointer isNotHelperButPlanarFigure = mitk::NodePredicateAnd::New( isPlanarFigure, isNotHelperObject );
 
   return this->GetDataStorage()->GetSubset( isPlanarFigure );
 }
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp
index f74a4bf5d1..3fab714a72 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp
@@ -1,644 +1,644 @@
 /*===================================================================
 
 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 "QmitkDeformableRegistrationView.h"
 #include "ui_QmitkDeformableRegistrationViewControls.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "qinputdialog.h"
 #include "qmessagebox.h"
 #include "qcursor.h"
 #include "qapplication.h"
 #include "qradiobutton.h"
 #include "qslider.h"
 
 #include <vtkTransform.h>
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkVectorImageMapper2D.h"
 #include <mitkImageCast.h>
 
 #include "itkImageFileReader.h"
 #include "itkWarpImageFilter.h"
 
 #include "mitkDataNodeObject.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 typedef itk::Vector< float, 3 >       VectorType;
 typedef itk::Image< VectorType, 3 >   DeformationFieldType;
 
 typedef itk::ImageFileReader< DeformationFieldType > ImageReaderType;
 
 const std::string QmitkDeformableRegistrationView::VIEW_ID = "org.mitk.views.deformableregistration";
 
 using namespace berry;
 
 struct SelListenerDeformableRegistration : ISelectionListener
 {
   berryObjectMacro(SelListenerDeformableRegistration);
 
   SelListenerDeformableRegistration(QmitkDeformableRegistrationView* view)
   {
     m_View = view;
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
 //    if(!m_View->IsVisible())
 //      return;
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     // do something with the selected items
     if(m_View->m_CurrentSelection)
     {
       if (m_View->m_CurrentSelection->Size() != 2)
       {
         if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
         {
           m_View->m_Controls.m_StatusLabel->show();
           m_View->m_Controls.TextLabelFixed->hide();
           m_View->m_Controls.m_SwitchImages->hide();
           m_View->m_Controls.m_FixedLabel->hide();
           m_View->m_Controls.TextLabelMoving->hide();
           m_View->m_Controls.m_MovingLabel->hide();
           m_View->m_Controls.m_OpacityLabel->setEnabled(false);
           m_View->m_Controls.m_OpacitySlider->setEnabled(false);
           m_View->m_Controls.label->setEnabled(false);
           m_View->m_Controls.label_2->setEnabled(false);
           m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
         }
       }
       else
       {
         m_View->m_Controls.m_StatusLabel->hide();
         bool foundFixedImage = false;
         mitk::DataNode::Pointer fixedNode;
         // iterate selection
         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
           i != m_View->m_CurrentSelection->End(); ++i)
         {
           // extract datatree node
           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
           {
             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
             // only look at interesting types
             if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
             {
               if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 4)
               {
                 m_View->m_Controls.m_StatusLabel->show();
                 QMessageBox::information( NULL, "DeformableRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
                 return;
               }
               if (foundFixedImage == false)
               {
                 fixedNode = node;
                 foundFixedImage = true;
               }
               else
               {
                 m_View->SetImagesVisible(selection);
                 m_View->FixedSelected(fixedNode);
                 m_View->MovingSelected(node);
                 m_View->m_Controls.m_StatusLabel->hide();
                 m_View->m_Controls.TextLabelFixed->show();
                 m_View->m_Controls.m_SwitchImages->show();
                 m_View->m_Controls.m_FixedLabel->show();
                 m_View->m_Controls.TextLabelMoving->show();
                 m_View->m_Controls.m_MovingLabel->show();
                 m_View->m_Controls.m_OpacityLabel->setEnabled(true);
                 m_View->m_Controls.m_OpacitySlider->setEnabled(true);
                 m_View->m_Controls.label->setEnabled(true);
                 m_View->m_Controls.label_2->setEnabled(true);
                 m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
               }
             }
             else
             {
               m_View->m_Controls.m_StatusLabel->show();
               return;
             }
           }
         }
       }
     }
     else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
     {
       m_View->m_Controls.m_StatusLabel->show();
     }
   }
 
   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname(part->GetPartName().c_str());
       if(partname.compare("Data Manager")==0)
       {
         // apply selection
         DoSelectionChanged(selection);
       }
     }
   }
 
   QmitkDeformableRegistrationView* m_View;
 };
 
 QmitkDeformableRegistrationView::QmitkDeformableRegistrationView(QObject * /*parent*/, const char * /*name*/)
 : QmitkFunctionality() , m_MultiWidget(NULL), m_MovingNode(NULL), m_FixedNode(NULL), m_ShowRedGreen(false),
   m_Opacity(0.5), m_OriginalOpacity(1.0), m_Deactivated(false)
 {
   this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkDeformableRegistrationView,
     const mitk::DataNode*> ( this, &QmitkDeformableRegistrationView::DataNodeHasBeenRemoved ));
 }
 
 QmitkDeformableRegistrationView::~QmitkDeformableRegistrationView()
 {
   if (m_SelListener.IsNotNull())
   {
     berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
     if(s)
       s->RemovePostSelectionListener(m_SelListener);
     m_SelListener = NULL;
   }
 }
 
 void QmitkDeformableRegistrationView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   m_Parent->setEnabled(false);
   this->CreateConnections();
   m_Controls.TextLabelFixed->hide();
   m_Controls.m_SwitchImages->hide();
   m_Controls.m_FixedLabel->hide();
   m_Controls.TextLabelMoving->hide();
   m_Controls.m_MovingLabel->hide();
   m_Controls.m_OpacityLabel->setEnabled(false);
   m_Controls.m_OpacitySlider->setEnabled(false);
   m_Controls.label->setEnabled(false);
   m_Controls.label_2->setEnabled(false);
   m_Controls.m_ShowRedGreenValues->setEnabled(false);
   m_Controls.m_DeformableTransform->hide();
   if (m_Controls.m_DeformableTransform->currentIndex() == 0)
   {
     m_Controls.m_QmitkDemonsRegistrationViewControls->show();
     m_Controls.m_QmitkBSplineRegistrationViewControls->hide();
   }
   else
   {
     m_Controls.m_QmitkDemonsRegistrationViewControls->hide();
     m_Controls.m_QmitkBSplineRegistrationViewControls->show();
   }
   this->CheckCalculateEnabled();
 }
 
 void QmitkDeformableRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
 {
   if(node == m_FixedNode || node == m_MovingNode)
   {
     m_Controls.m_StatusLabel->show();
     m_Controls.TextLabelFixed->hide();
     m_Controls.m_SwitchImages->hide();
     m_Controls.m_FixedLabel->hide();
     m_Controls.TextLabelMoving->hide();
     m_Controls.m_MovingLabel->hide();
     m_Controls.m_OpacityLabel->setEnabled(false);
     m_Controls.m_OpacitySlider->setEnabled(false);
     m_Controls.label->setEnabled(false);
     m_Controls.label_2->setEnabled(false);
     m_Controls.m_ShowRedGreenValues->setEnabled(false);
     m_Controls.m_DeformableTransform->hide();
     m_Controls.m_CalculateTransformation->setEnabled(false);
   }
 
 }
 
 
 void QmitkDeformableRegistrationView::ApplyDeformationField()
 {
 
   ImageReaderType::Pointer reader  = ImageReaderType::New();
   reader->SetFileName( m_Controls.m_QmitkBSplineRegistrationViewControls->m_Controls.m_DeformationField->text().toStdString() );
   reader->Update();
 
   DeformationFieldType::Pointer deformationField = reader->GetOutput();
 
   mitk::Image * mimage = dynamic_cast<mitk::Image*> (m_MovingNode->GetData());
   mitk::Image * fimage = dynamic_cast<mitk::Image*> (m_FixedNode->GetData());
 
   typedef itk::Image<float, 3> FloatImageType;
 
   FloatImageType::Pointer itkMovingImage = FloatImageType::New();
   FloatImageType::Pointer itkFixedImage = FloatImageType::New();
   mitk::CastToItkImage(mimage, itkMovingImage);
   mitk::CastToItkImage(fimage, itkFixedImage);
 
   typedef itk::WarpImageFilter<
                             FloatImageType,
                             FloatImageType,
                             DeformationFieldType  >     WarperType;
 
   typedef itk::LinearInterpolateImageFunction<
                                     FloatImageType,
                                     double          >  InterpolatorType;
 
   WarperType::Pointer warper = WarperType::New();
   InterpolatorType::Pointer interpolator = InterpolatorType::New();
 
   warper->SetInput( itkMovingImage );
   warper->SetInterpolator( interpolator );
   warper->SetOutputSpacing( itkFixedImage->GetSpacing() );
   warper->SetOutputOrigin( itkFixedImage->GetOrigin() );
   warper->SetOutputDirection (itkFixedImage->GetDirection() );
   warper->SetDisplacementField( deformationField );
   warper->Update();
 
   FloatImageType::Pointer outputImage = warper->GetOutput();
   mitk::Image::Pointer result = mitk::Image::New();
 
   mitk::CastToMitkImage(outputImage, result);
 
   // Create new DataNode
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetData( result );
   newNode->SetProperty( "name", mitk::StringProperty::New("warped image") );
 
   // add the new datatree node to the datatree
   this->GetDefaultDataStorage()->Add(newNode);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   //Image::Pointer outputImage = this->GetOutput();
   //mitk::CastToMitkImage( warper->GetOutput(), outputImage );
 
 
 }
 
 void QmitkDeformableRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_Parent->setEnabled(true);
   m_MultiWidget = &stdMultiWidget;
   m_MultiWidget->SetWidgetPlanesVisibility(true);
 }
 
 void QmitkDeformableRegistrationView::StdMultiWidgetNotAvailable()
 {
   m_Parent->setEnabled(false);
   m_MultiWidget = NULL;
 }
 
 void QmitkDeformableRegistrationView::CreateConnections()
 {
   connect(m_Controls.m_ShowRedGreenValues, SIGNAL(toggled(bool)), this, SLOT(ShowRedGreen(bool)));
   connect(m_Controls.m_DeformableTransform, SIGNAL(currentChanged(int)), this, SLOT(TabChanged(int)));
   connect(m_Controls.m_OpacitySlider, SIGNAL(sliderMoved(int)), this, SLOT(OpacityUpdate(int)));
   connect(m_Controls.m_CalculateTransformation, SIGNAL(clicked()), this, SLOT(Calculate()));
   connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
   connect(this,SIGNAL(calculateBSplineRegistration()),m_Controls.m_QmitkBSplineRegistrationViewControls,SLOT(CalculateTransformation()));
   connect( (QObject*)(m_Controls.m_QmitkBSplineRegistrationViewControls->m_Controls.m_ApplyDeformationField),
     SIGNAL(clicked()),
     (QObject*) this,
     SLOT(ApplyDeformationField()) );
 }
 
 void QmitkDeformableRegistrationView::Activated()
 {
   m_Deactivated = false;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Activated();
   if (m_SelListener.IsNull())
   {
     m_SelListener = berry::ISelectionListener::Pointer(new SelListenerDeformableRegistration(this));
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
     berry::ISelection::ConstPointer sel(
       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
     m_CurrentSelection = sel.Cast<const IStructuredSelection>();
     m_SelListener.Cast<SelListenerDeformableRegistration>()->DoSelectionChanged(sel);
   }
   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
   this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
 }
 
 void QmitkDeformableRegistrationView::Visible()
 {
   /*
   m_Deactivated = false;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Activated();
   if (m_SelListener.IsNull())
   {
     m_SelListener = berry::ISelectionListener::Pointer(new SelListenerDeformableRegistration(this));
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener("org.mitk.views.datamanager", m_SelListener);
     berry::ISelection::ConstPointer sel(
       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
     m_CurrentSelection = sel.Cast<const IStructuredSelection>();
     m_SelListener.Cast<SelListenerDeformableRegistration>()->DoSelectionChanged(sel);
   }
   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
   this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());*/
 }
 
 void QmitkDeformableRegistrationView::Deactivated()
 {
   m_Deactivated = true;
   this->SetImageColor(false);
   if (m_FixedNode.IsNotNull())
     m_FixedNode->SetOpacity(1.0);
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_OriginalOpacity);
   }
   m_FixedNode = NULL;
   m_MovingNode = NULL;
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
     s->RemovePostSelectionListener(m_SelListener);
   m_SelListener = NULL;
 }
 
 void QmitkDeformableRegistrationView::Hidden()
 {
   /*
   m_Deactivated = true;
   this->SetImageColor(false);
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_OriginalOpacity);
   }
   m_FixedNode = NULL;
   m_MovingNode = NULL;
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
     s->RemovePostSelectionListener(m_SelListener);
   m_SelListener = NULL;*/
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   //QmitkFunctionality::Deactivated();
 }
 
 void QmitkDeformableRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
 {
   if (fixedImage.IsNotNull())
   {
     if (m_FixedNode != fixedImage)
     {
       // remove changes on previous selected node
       if (m_FixedNode.IsNotNull())
       {
         this->SetImageColor(false);
         m_FixedNode->SetOpacity(1.0);
         m_FixedNode->SetVisibility(false);
         m_FixedNode->SetProperty("selectedFixedImage", mitk::BoolProperty::New(false));
       }
       // get selected node
       m_FixedNode = fixedImage;
       m_FixedNode->SetOpacity(0.5);
       m_Controls.TextLabelFixed->setText(QString::fromStdString(m_FixedNode->GetName()));
       m_Controls.m_FixedLabel->show();
       m_Controls.TextLabelFixed->show();
       m_Controls.m_SwitchImages->show();
       mitk::ColorProperty::Pointer colorProperty;
       colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
       if ( colorProperty.IsNotNull() )
       {
         m_FixedColor = colorProperty->GetColor();
       }
       this->SetImageColor(m_ShowRedGreen);
       m_FixedNode->SetVisibility(true);
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   else
   {
     m_FixedNode = fixedImage;
     m_Controls.m_FixedLabel->hide();
     m_Controls.TextLabelFixed->hide();
     m_Controls.m_SwitchImages->hide();
   }
   this->CheckCalculateEnabled();
 }
 
 void QmitkDeformableRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
 {
   if (movingImage.IsNotNull())
   {
     if (m_MovingNode != movingImage)
     {
       if (m_MovingNode.IsNotNull())
       {
         m_MovingNode->SetOpacity(m_OriginalOpacity);
         if (m_FixedNode == m_MovingNode)
           m_FixedNode->SetOpacity(0.5);
         this->SetImageColor(false);
       }
       m_MovingNode = movingImage;
       m_Controls.TextLabelMoving->setText(QString::fromStdString(m_MovingNode->GetName()));
       m_Controls.m_MovingLabel->show();
       m_Controls.TextLabelMoving->show();
       mitk::ColorProperty::Pointer colorProperty;
       colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
       if ( colorProperty.IsNotNull() )
       {
         m_MovingColor = colorProperty->GetColor();
       }
       this->SetImageColor(m_ShowRedGreen);
       m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
       this->OpacityUpdate(m_Opacity);
       m_MovingNode->SetVisibility(true);
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   else
   {
     m_MovingNode = NULL;
     m_Controls.m_MovingLabel->hide();
     m_Controls.TextLabelMoving->hide();
   }
   this->CheckCalculateEnabled();
 }
 
 bool QmitkDeformableRegistrationView::CheckCalculate()
 {
   if(m_MovingNode==m_FixedNode)
     return false;
   return true;
 }
 
 void QmitkDeformableRegistrationView::ShowRedGreen(bool redGreen)
 {
   m_ShowRedGreen = redGreen;
   this->SetImageColor(m_ShowRedGreen);
 }
 
 void QmitkDeformableRegistrationView::SetImageColor(bool redGreen)
 {
   if (!redGreen && m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetColor(m_FixedColor);
   }
   if (!redGreen && m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetColor(m_MovingColor);
   }
   if (redGreen && m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
   }
   if (redGreen && m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDeformableRegistrationView::OpacityUpdate(float opacity)
 {
   m_Opacity = opacity;
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_Opacity);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDeformableRegistrationView::OpacityUpdate(int opacity)
 {
   float fValue = ((float)opacity)/100.0f;
   this->OpacityUpdate(fValue);
 }
 
 void QmitkDeformableRegistrationView::CheckCalculateEnabled()
 {
   if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
   {
     m_Controls.m_CalculateTransformation->setEnabled(true);
   }
   else
   {
     m_Controls.m_CalculateTransformation->setEnabled(false);
   }
 }
 
 void QmitkDeformableRegistrationView::Calculate()
 {
   if (m_Controls.m_DeformableTransform->tabText(m_Controls.m_DeformableTransform->currentIndex()) == "Demons")
   {
     m_Controls.m_QmitkDemonsRegistrationViewControls->SetFixedNode(m_FixedNode);
     m_Controls.m_QmitkDemonsRegistrationViewControls->SetMovingNode(m_MovingNode);
     try
     {
       m_Controls.m_QmitkDemonsRegistrationViewControls->CalculateTransformation();
     }
     catch (itk::ExceptionObject& excpt)
     {
       QMessageBox::information( NULL, "Registration exception", excpt.GetDescription(), QMessageBox::Ok );
       return;
     }
     mitk::Image::Pointer resultImage = m_Controls.m_QmitkDemonsRegistrationViewControls->GetResultImage();
     mitk::Image::Pointer resultDeformationField = m_Controls.m_QmitkDemonsRegistrationViewControls->GetResultDeformationfield();
     if (resultImage.IsNotNull())
     {
       mitk::DataNode::Pointer resultImageNode = mitk::DataNode::New();
       resultImageNode->SetData(resultImage);
       mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
       mitk::LevelWindow levelWindow;
       levelWindow.SetAuto( resultImage );
       levWinProp->SetLevelWindow(levelWindow);
       resultImageNode->GetPropertyList()->SetProperty("levelwindow",levWinProp);
       resultImageNode->SetStringProperty("name", "DeformableRegistrationResultImage");
       this->GetDataStorage()->Add(resultImageNode, m_MovingNode);
     }
     if (resultDeformationField.IsNotNull())
     {
       mitk::DataNode::Pointer resultDeformationFieldNode = mitk::DataNode::New();
       resultDeformationFieldNode->SetData(resultDeformationField);
       mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
       mitk::LevelWindow levelWindow;
       levelWindow.SetAuto( resultDeformationField );
       levWinProp->SetLevelWindow(levelWindow);
       resultDeformationFieldNode->GetPropertyList()->SetProperty("levelwindow",levWinProp);
       resultDeformationFieldNode->SetStringProperty("name", "DeformableRegistrationResultDeformationField");
       mitk::VectorImageMapper2D::Pointer mapper = mitk::VectorImageMapper2D::New();
       resultDeformationFieldNode->SetMapper(1, mapper);
       resultDeformationFieldNode->SetVisibility(false);
       this->GetDataStorage()->Add(resultDeformationFieldNode, m_MovingNode);
     }
   }
 
   else if (m_Controls.m_DeformableTransform->tabText(m_Controls.m_DeformableTransform->currentIndex()) == "B-Spline")
   {
     m_Controls.m_QmitkBSplineRegistrationViewControls->SetFixedNode(m_FixedNode);
     m_Controls.m_QmitkBSplineRegistrationViewControls->SetMovingNode(m_MovingNode);
     emit calculateBSplineRegistration();
   }
 }
 
 void QmitkDeformableRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
 {
   if (this->m_CurrentSelection->Size() == 0)
   {
     // show all images
     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
     {
-      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
+      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::PlaneGeometryData*>(nodeIt->Value()->GetData())==NULL)
       {
         nodeIt->Value()->SetVisibility(true);
       }
     }
   }
   else
   {
     // hide all images
     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
     {
-      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
+      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::PlaneGeometryData*>(nodeIt->Value()->GetData())==NULL)
       {
         nodeIt->Value()->SetVisibility(false);
       }
     }
   }
 }
 
 void QmitkDeformableRegistrationView::TabChanged(int index)
 {
   if (index == 0)
   {
     m_Controls.m_QmitkDemonsRegistrationViewControls->show();
     m_Controls.m_QmitkBSplineRegistrationViewControls->hide();
   }
   else
   {
     m_Controls.m_QmitkDemonsRegistrationViewControls->hide();
     m_Controls.m_QmitkBSplineRegistrationViewControls->show();
   }
 }
 
 void QmitkDeformableRegistrationView::SwitchImages()
 {
   mitk::DataNode::Pointer newMoving = m_FixedNode;
   mitk::DataNode::Pointer newFixed = m_MovingNode;
   this->FixedSelected(newFixed);
   this->MovingSelected(newMoving);
 }
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
index 64293e2587..7ccd197187 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
@@ -1,1368 +1,1368 @@
 /*===================================================================
 
 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 "QmitkPointBasedRegistrationView.h"
 #include "ui_QmitkPointBasedRegistrationViewControls.h"
 #include "QmitkPointListWidget.h"
 
 #include <vtkIterativeClosestPointTransform.h>
 #include <vtkMatrix4x4.h>
 #include <vtkMath.h>
 #include "vtkPolyData.h"
 
 #include <vtkLandmarkTransform.h>
 #include <QmitkStdMultiWidget.h>
 #include "qradiobutton.h"
 #include "qapplication.h"
 #include <qcursor.h>
 #include <qinputdialog.h>
 #include <qlcdnumber.h>
 #include <qlabel.h>
 #include "qmessagebox.h"
 
 #include "mitkLandmarkWarping.h"
 #include <mitkPointOperation.h>
 #include <mitkPositionEvent.h>
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include <mitkPointSetWriter.h>
 #include <mitkPointSetReader.h>
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateNot.h"
 #include <mitkMessage.h>
 #include <mitkImageCast.h>
 
 #include <itkCommand.h>
 
 #include "mitkDataNodeObject.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 
 const std::string QmitkPointBasedRegistrationView::VIEW_ID = "org.mitk.views.pointbasedregistration";
 
 using namespace berry;
 
 struct SelListenerPointBasedRegistration : ISelectionListener
 {
   berryObjectMacro(SelListenerPointBasedRegistration);
 
   SelListenerPointBasedRegistration(QmitkPointBasedRegistrationView* view)
   {
     m_View = view;
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     //    if(!m_View->IsVisible())
     //      return;
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     // do something with the selected items
     if(m_View->m_CurrentSelection)
     {
       if (m_View->m_CurrentSelection->Size() != 2)
       {
         if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
         {
           m_View->m_Controls.m_StatusLabel->show();
           m_View->m_Controls.TextLabelFixed->hide();
           m_View->m_Controls.m_FixedLabel->hide();
           m_View->m_Controls.line2->hide();
           m_View->m_Controls.m_FixedPointListWidget->hide();
           m_View->m_Controls.TextLabelMoving->hide();
           m_View->m_Controls.m_MovingLabel->hide();
           m_View->m_Controls.line1->hide();
           m_View->m_Controls.m_MovingPointListWidget->hide();
           m_View->m_Controls.m_OpacityLabel->hide();
           m_View->m_Controls.m_OpacitySlider->hide();
           m_View->m_Controls.label->hide();
           m_View->m_Controls.label_2->hide();
           m_View->m_Controls.m_SwitchImages->hide();
           m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
         }
       }
       else
       {
         m_View->m_Controls.m_StatusLabel->hide();
         bool foundFixedImage = false;
         mitk::DataNode::Pointer fixedNode;
         // iterate selection
         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
              i != m_View->m_CurrentSelection->End(); ++i)
         {
           // extract datatree node
           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
           {
             mitk::TNodePredicateDataType<mitk::BaseData>::Pointer isBaseData(mitk::TNodePredicateDataType<mitk::BaseData>::New());
             mitk::TNodePredicateDataType<mitk::PointSet>::Pointer isPointSet(mitk::TNodePredicateDataType<mitk::PointSet>::New());
             mitk::NodePredicateNot::Pointer notPointSet = mitk::NodePredicateNot::New(isPointSet);
-            mitk::TNodePredicateDataType<mitk::Geometry2DData>::Pointer isGeometry2DData(mitk::TNodePredicateDataType<mitk::Geometry2DData>::New());
-            mitk::NodePredicateNot::Pointer notGeometry2DData = mitk::NodePredicateNot::New(isGeometry2DData);
-            mitk::NodePredicateAnd::Pointer notPointSetAndNotGeometry2DData = mitk::NodePredicateAnd::New( notPointSet, notGeometry2DData );
-            mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New( isBaseData, notPointSetAndNotGeometry2DData );
+            mitk::TNodePredicateDataType<mitk::PlaneGeometryData>::Pointer isPlaneGeometryData(mitk::TNodePredicateDataType<mitk::PlaneGeometryData>::New());
+            mitk::NodePredicateNot::Pointer notPlaneGeometryData = mitk::NodePredicateNot::New(isPlaneGeometryData);
+            mitk::NodePredicateAnd::Pointer notPointSetAndNotPlaneGeometryData = mitk::NodePredicateAnd::New( notPointSet, notPlaneGeometryData );
+            mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New( isBaseData, notPointSetAndNotPlaneGeometryData );
 
 
             mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = m_View->GetDataStorage()->GetSubset(predicate);
 
             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
             // only look at interesting types
             for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
                  ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
             {
               if(nodeIt->Value().GetPointer() == node.GetPointer())
               {
                 // was - compare()
                 // use contain to allow other Image types to be selected, i.e. a diffusion image
                 if (QString( node->GetData()->GetNameOfClass() ).contains("Image") )
                 {
                   // verify that the node selected by name is really an image or derived class
                   mitk::Image* _image = dynamic_cast<mitk::Image*>(node->GetData());
                   if (_image != NULL)
                   {
                     if( _image->GetDimension() == 4)
                     {
                       m_View->m_Controls.m_StatusLabel->show();
                       QMessageBox::information( NULL, "PointBasedRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
                       return;
                     }
                     if (foundFixedImage == false)
                     {
                       fixedNode = node;
                       foundFixedImage = true;
                     }
                     else
                     {
                       m_View->SetImagesVisible(selection);
                       m_View->FixedSelected(fixedNode);
                       m_View->MovingSelected(node);
                       m_View->m_Controls.m_StatusLabel->hide();
                       m_View->m_Controls.TextLabelFixed->show();
                       m_View->m_Controls.m_FixedLabel->show();
                       m_View->m_Controls.line2->show();
                       m_View->m_Controls.m_FixedPointListWidget->show();
                       m_View->m_Controls.TextLabelMoving->show();
                       m_View->m_Controls.m_MovingLabel->show();
                       m_View->m_Controls.line1->show();
                       m_View->m_Controls.m_MovingPointListWidget->show();
                       m_View->m_Controls.m_OpacityLabel->show();
                       m_View->m_Controls.m_OpacitySlider->show();
                       m_View->m_Controls.label->show();
                       m_View->m_Controls.label_2->show();
                       m_View->m_Controls.m_SwitchImages->show();
                       m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
                     }
                   }
                 }
 
                 else
                 {
                   m_View->m_Controls.m_StatusLabel->show();
                   return;
                 }
 
               }
             }
           }
         }
         if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
         {
           m_View->m_Controls.m_StatusLabel->show();
         }
       }
     }
     else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
     {
       m_View->m_Controls.m_StatusLabel->show();
     }
   }
 
   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname(part->GetPartName().c_str());
       if(partname.compare("Data Manager")==0)
       {
         // apply selection
         DoSelectionChanged(selection);
       }
     }
   }
 
   QmitkPointBasedRegistrationView* m_View;
 };
 
 
 QmitkPointBasedRegistrationView::QmitkPointBasedRegistrationView(QObject * /*parent*/, const char * /*name*/)
 : QmitkFunctionality(), m_SelListener(0), m_MultiWidget(NULL), m_FixedLandmarks(NULL), m_MovingLandmarks(NULL), m_MovingNode(NULL),
 m_FixedNode(NULL), m_ShowRedGreen(false), m_Opacity(0.5), m_OriginalOpacity(1.0), m_Transformation(0), m_HideFixedImage(false), m_HideMovingImage(false),
 m_OldFixedLabel(""), m_OldMovingLabel(""), m_Deactivated (false), m_CurrentFixedLandmarksObserverID(0), m_CurrentMovingLandmarksObserverID(0)
 {
   m_FixedLandmarksChangedCommand = itk::SimpleMemberCommand<QmitkPointBasedRegistrationView>::New();
   m_FixedLandmarksChangedCommand->SetCallbackFunction(this, &QmitkPointBasedRegistrationView::updateFixedLandmarksList);
   m_MovingLandmarksChangedCommand = itk::SimpleMemberCommand<QmitkPointBasedRegistrationView>::New();
   m_MovingLandmarksChangedCommand->SetCallbackFunction(this, &QmitkPointBasedRegistrationView::updateMovingLandmarksList);
 
   this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkPointBasedRegistrationView,
     const mitk::DataNode*> ( this, &QmitkPointBasedRegistrationView::DataNodeHasBeenRemoved ));
 
 }
 
 QmitkPointBasedRegistrationView::~QmitkPointBasedRegistrationView()
 {
   if(m_SelListener.IsNotNull())
   {
     berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
     if(s)
       s->RemovePostSelectionListener(m_SelListener);
     m_SelListener = NULL;
   }
   if (m_FixedPointSetNode.IsNotNull())
   {
     m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
     m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
   }
   if (m_MovingPointSetNode.IsNotNull())
   {
     m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
     m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
   }
   m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
   m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
 }
 
 void QmitkPointBasedRegistrationView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   m_Parent->setEnabled(false);
   m_Controls.m_MeanErrorLCD->hide();
   m_Controls.m_MeanError->hide();
   m_Controls.TextLabelFixed->hide();
   m_Controls.line2->hide();
   m_Controls.m_FixedPointListWidget->hide();
   m_Controls.m_FixedLabel->hide();
   m_Controls.TextLabelMoving->hide();
   m_Controls.m_MovingLabel->hide();
   m_Controls.line1->hide();
   m_Controls.m_MovingPointListWidget->hide();
   m_Controls.m_OpacityLabel->hide();
   m_Controls.m_OpacitySlider->hide();
   m_Controls.label->hide();
   m_Controls.label_2->hide();
   m_Controls.m_SwitchImages->hide();
   m_Controls.m_ShowRedGreenValues->setEnabled(false);
 
   this->CreateConnections();
 
   // let the point set widget know about the multi widget (cross hair updates)
   m_Controls.m_FixedPointListWidget->SetMultiWidget( m_MultiWidget );
   m_Controls.m_MovingPointListWidget->SetMultiWidget( m_MultiWidget );
 }
 
 void QmitkPointBasedRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_Parent->setEnabled(true);
   m_MultiWidget = &stdMultiWidget;
   m_MultiWidget->SetWidgetPlanesVisibility(true);
   m_Controls.m_FixedPointListWidget->SetMultiWidget( m_MultiWidget );
   m_Controls.m_MovingPointListWidget->SetMultiWidget( m_MultiWidget );
 }
 
 void QmitkPointBasedRegistrationView::StdMultiWidgetNotAvailable()
 {
   m_Parent->setEnabled(false);
   m_MultiWidget = NULL;
   m_Controls.m_FixedPointListWidget->SetMultiWidget( NULL );
   m_Controls.m_MovingPointListWidget->SetMultiWidget( NULL );
 }
 
 void QmitkPointBasedRegistrationView::CreateConnections()
 {
   connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(EditPointSets(bool)), (QObject*)(m_Controls.m_MovingPointListWidget), SLOT(DeactivateInteractor(bool)));
   connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(EditPointSets(bool)), (QObject*)(m_Controls.m_FixedPointListWidget), SLOT(DeactivateInteractor(bool)));
   connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(EditPointSets(bool)), this, SLOT(HideMovingImage(bool)));
   connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(EditPointSets(bool)), this, SLOT(HideFixedImage(bool)));
   connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(PointListChanged()), this, SLOT(updateFixedLandmarksList()));
   connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(PointListChanged()), this, SLOT(updateMovingLandmarksList()));
   connect((QObject*)(m_Controls.m_Calculate),SIGNAL(clicked()),this,SLOT(calculate()));
   connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
   connect((QObject*)(m_Controls.m_UndoTransformation),SIGNAL(clicked()),this,SLOT(UndoTransformation()));
   connect((QObject*)(m_Controls.m_RedoTransformation),SIGNAL(clicked()),this,SLOT(RedoTransformation()));
   connect((QObject*)(m_Controls.m_ShowRedGreenValues),SIGNAL(toggled(bool)),this,SLOT(showRedGreen(bool)));
   connect((QObject*)(m_Controls.m_OpacitySlider),SIGNAL(valueChanged(int)),this,SLOT(OpacityUpdate(int)));
   connect((QObject*)(m_Controls.m_SelectedTransformationClass),SIGNAL(activated(int)), this,SLOT(transformationChanged(int)));
   connect((QObject*)(m_Controls.m_UseICP),SIGNAL(toggled(bool)), this,SLOT(checkCalculateEnabled()));
   connect((QObject*)(m_Controls.m_UseICP),SIGNAL(toggled(bool)), this,SLOT(checkLandmarkError()));
 }
 
 void QmitkPointBasedRegistrationView::Activated()
 {
 
   m_Deactivated = false;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Activated();
   this->clearTransformationLists();
   if (m_SelListener.IsNull())
   {
     m_SelListener = berry::ISelectionListener::Pointer(new SelListenerPointBasedRegistration(this));
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
     berry::ISelection::ConstPointer sel(
       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
     m_CurrentSelection = sel.Cast<const IStructuredSelection>();
     m_SelListener.Cast<SelListenerPointBasedRegistration>()->DoSelectionChanged(sel);
   }
   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
   this->showRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
 
 
 
 }
 
 void QmitkPointBasedRegistrationView::Visible()
 {
 
 }
 
 void QmitkPointBasedRegistrationView::Deactivated()
 {
 
   m_Deactivated = true;
   if (m_FixedPointSetNode.IsNotNull())
     m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
   m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
   m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
   if (m_MovingPointSetNode.IsNotNull())
     m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
   m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
   m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
   this->setImageColor(false);
   if (m_FixedNode.IsNotNull())
     m_FixedNode->SetOpacity(1.0);
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_OriginalOpacity);
   }
   this->clearTransformationLists();
   if (m_FixedPointSetNode.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_FixedLandmarks->GetSize() == 0)
   {
     this->GetDataStorage()->Remove(m_FixedPointSetNode);
   }
   if (m_MovingPointSetNode.IsNotNull() && m_MovingLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() == 0)
   {
     this->GetDataStorage()->Remove(m_MovingPointSetNode);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   m_FixedNode = NULL;
   m_MovingNode = NULL;
   if(m_FixedLandmarks.IsNotNull())
     m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
   m_FixedLandmarks = NULL;
   if(m_MovingLandmarks.IsNotNull())
     m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
   m_MovingLandmarks = NULL;
   m_FixedPointSetNode = NULL;
   m_MovingPointSetNode = NULL;
   m_Controls.m_FixedLabel->hide();
   m_Controls.TextLabelFixed->hide();
   m_Controls.line2->hide();
   m_Controls.m_FixedPointListWidget->hide();
   m_Controls.m_MovingLabel->hide();
   m_Controls.TextLabelMoving->hide();
   m_Controls.line1->hide();
   m_Controls.m_MovingPointListWidget->hide();
   m_Controls.m_OpacityLabel->hide();
   m_Controls.m_OpacitySlider->hide();
   m_Controls.label->hide();
   m_Controls.label_2->hide();
   m_Controls.m_SwitchImages->hide();
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
     s->RemovePostSelectionListener(m_SelListener);
   m_SelListener = NULL;
 
 }
 
 void QmitkPointBasedRegistrationView::Hidden()
 {
   /*
   m_Deactivated = true;
   if (m_FixedPointSetNode.IsNotNull())
     m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
   m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
   m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
   if (m_MovingPointSetNode.IsNotNull())
     m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
   m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
   m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
   this->setImageColor(false);
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_OriginalOpacity);
   }
   this->clearTransformationLists();
   if (m_FixedPointSetNode.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_FixedLandmarks->GetSize() == 0)
   {
     this->GetDataStorage()->Remove(m_FixedPointSetNode);
   }
   if (m_MovingPointSetNode.IsNotNull() && m_MovingLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() == 0)
   {
     this->GetDataStorage()->Remove(m_MovingPointSetNode);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   m_FixedNode = NULL;
   m_MovingNode = NULL;
   if(m_FixedLandmarks.IsNotNull())
     m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
   m_FixedLandmarks = NULL;
   if(m_MovingLandmarks.IsNotNull())
     m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
   m_MovingLandmarks = NULL;
   m_FixedPointSetNode = NULL;
   m_MovingPointSetNode = NULL;
   m_Controls.m_FixedLabel->hide();
   m_Controls.TextLabelFixed->hide();
   m_Controls.line2->hide();
   m_Controls.m_FixedPointListWidget->hide();
   m_Controls.m_MovingLabel->hide();
   m_Controls.TextLabelMoving->hide();
   m_Controls.line1->hide();
   m_Controls.m_MovingPointListWidget->hide();
   m_Controls.m_OpacityLabel->hide();
   m_Controls.m_OpacitySlider->hide();
   m_Controls.label->hide();
   m_Controls.label_2->hide();
   m_Controls.m_SwitchImages->hide();
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
     s->RemovePostSelectionListener(m_SelListener);
   m_SelListener = NULL;
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   //QmitkFunctionality::Deactivated();*/
 }
 
 
 void QmitkPointBasedRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
 {
   if(node == m_FixedNode || node == m_MovingNode)
   {
     m_Controls.m_StatusLabel->show();
     m_Controls.TextLabelFixed->hide();
     m_Controls.m_FixedLabel->hide();
     m_Controls.line2->hide();
     m_Controls.m_FixedPointListWidget->hide();
     m_Controls.TextLabelMoving->hide();
     m_Controls.m_MovingLabel->hide();
     m_Controls.line1->hide();
     m_Controls.m_MovingPointListWidget->hide();
     m_Controls.m_OpacityLabel->hide();
     m_Controls.m_OpacitySlider->hide();
     m_Controls.label->hide();
     m_Controls.label_2->hide();
     m_Controls.m_SwitchImages->hide();
     m_Controls.m_ShowRedGreenValues->setEnabled(false);
   }
 
 }
 
 void QmitkPointBasedRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
 {
   if(m_FixedLandmarks.IsNotNull())
     m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
   if (fixedImage.IsNotNull())
   {
     if (m_FixedNode != fixedImage)
     {
       // remove changes on previous selected node
       if (m_FixedNode.IsNotNull())
       {
         this->setImageColor(false);
         m_FixedNode->SetOpacity(1.0);
         if (m_FixedPointSetNode.IsNotNull())
         {
           m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
         }
       }
       // get selected node
       m_FixedNode = fixedImage;
       m_FixedNode->SetOpacity(0.5);
       m_FixedNode->SetVisibility(true);
       m_Controls.m_FixedLabel->setText(QString::fromStdString(m_FixedNode->GetName()));
       m_Controls.m_FixedLabel->show();
       m_Controls.m_SwitchImages->show();
       m_Controls.TextLabelFixed->show();
       m_Controls.line2->show();
       m_Controls.m_FixedPointListWidget->show();
       mitk::ColorProperty::Pointer colorProperty;
       colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
       if ( colorProperty.IsNotNull() )
       {
         m_FixedColor = colorProperty->GetColor();
       }
       this->setImageColor(m_ShowRedGreen);
 
       bool hasPointSetNode = false;
       mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_FixedNode);
       unsigned long size;
       size = children->Size();
       for (unsigned long i = 0; i < size; ++i)
       {
         mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(children->GetElement(i)->GetProperty("name"));
         if(nameProp.IsNotNull() && nameProp->GetValueAsString()=="PointBasedRegistrationNode")
         {
           m_FixedPointSetNode=children->GetElement(i);
           m_FixedLandmarks = dynamic_cast<mitk::PointSet*> (m_FixedPointSetNode->GetData());
           this->GetDataStorage()->Remove(m_FixedPointSetNode);
           hasPointSetNode = true;
           break;
         }
       }
       if (!hasPointSetNode)
       {
         m_FixedLandmarks = mitk::PointSet::New();
         m_FixedPointSetNode = mitk::DataNode::New();
         m_FixedPointSetNode->SetData(m_FixedLandmarks);
         m_FixedPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
       }
       m_FixedPointSetNode->GetStringProperty("label", m_OldFixedLabel);
       m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New("F "));
       m_FixedPointSetNode->SetProperty("color", mitk::ColorProperty::New(0.0f, 1.0f, 1.0f));
       m_FixedPointSetNode->SetVisibility(true);
       m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
       this->GetDataStorage()->Add(m_FixedPointSetNode, m_FixedNode);
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     if (m_FixedPointSetNode.IsNull())
     {
       m_FixedLandmarks = mitk::PointSet::New();
       m_FixedPointSetNode = mitk::DataNode::New();
       m_FixedPointSetNode->SetData(m_FixedLandmarks);
       m_FixedPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
 
       m_FixedPointSetNode->GetStringProperty("label", m_OldFixedLabel);
       m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New("F "));
       m_FixedPointSetNode->SetProperty("color", mitk::ColorProperty::New(0.0f, 1.0f, 1.0f));
       m_FixedPointSetNode->SetVisibility(true);
       m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
       this->GetDataStorage()->Add(m_FixedPointSetNode, m_FixedNode);
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   else
   {
     m_FixedNode = NULL;
     if (m_FixedPointSetNode.IsNotNull())
       m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
     m_FixedPointSetNode = NULL;
     m_FixedLandmarks = NULL;
     m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
     m_Controls.m_FixedLabel->hide();
     m_Controls.TextLabelFixed->hide();
     m_Controls.line2->hide();
     m_Controls.m_FixedPointListWidget->hide();
     m_Controls.m_SwitchImages->hide();
   }
   if(m_FixedLandmarks.IsNotNull())
     m_CurrentFixedLandmarksObserverID = m_FixedLandmarks->AddObserver(itk::ModifiedEvent(), m_FixedLandmarksChangedCommand);
 }
 
 void QmitkPointBasedRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
 {
   if(m_MovingLandmarks.IsNotNull())
     m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
   if (movingImage.IsNotNull())
   {
     if (m_MovingNode != movingImage)
     {
       if (m_MovingNode.IsNotNull())
       {
         m_MovingNode->SetOpacity(m_OriginalOpacity);
         if (m_FixedNode == m_MovingNode)
           m_FixedNode->SetOpacity(0.5);
         this->setImageColor(false);
         if (m_MovingNode != m_FixedNode)
         {
           m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
         }
         else
         {
           m_OldFixedLabel = m_OldMovingLabel;
         }
       }
       if (m_MovingPointSetNode.IsNotNull())
         m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
       m_MovingNode = movingImage;
       m_MovingNode->SetVisibility(true);
       m_Controls.m_MovingLabel->setText(QString::fromStdString(m_MovingNode->GetName()));
       m_Controls.m_MovingLabel->show();
       m_Controls.TextLabelMoving->show();
       m_Controls.line1->show();
       m_Controls.m_MovingPointListWidget->show();
       m_Controls.m_OpacityLabel->show();
       m_Controls.m_OpacitySlider->show();
       m_Controls.label->show();
       m_Controls.label_2->show();
       mitk::ColorProperty::Pointer colorProperty;
       colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
       if ( colorProperty.IsNotNull() )
       {
         m_MovingColor = colorProperty->GetColor();
       }
       this->setImageColor(m_ShowRedGreen);
       m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
       this->OpacityUpdate(m_Opacity);
       bool hasPointSetNode = false;
       mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
       unsigned long size;
       size = children->Size();
       for (unsigned long i = 0; i < size; ++i)
       {
         mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(children->GetElement(i)->GetProperty("name"));
         if(nameProp.IsNotNull() && nameProp->GetValueAsString()=="PointBasedRegistrationNode")
         {
           m_MovingPointSetNode=children->GetElement(i);
           m_MovingLandmarks = dynamic_cast<mitk::PointSet*> (m_MovingPointSetNode->GetData());
           this->GetDataStorage()->Remove(m_MovingPointSetNode);
           hasPointSetNode = true;
           break;
         }
       }
       if (!hasPointSetNode)
       {
         m_MovingLandmarks = mitk::PointSet::New();
         m_MovingPointSetNode = mitk::DataNode::New();
         m_MovingPointSetNode->SetData(m_MovingLandmarks);
         m_MovingPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
       }
       this->GetDataStorage()->Add(m_MovingPointSetNode, m_MovingNode);
       m_MovingPointSetNode->GetStringProperty("label", m_OldMovingLabel);
       m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New("M "));
       m_MovingPointSetNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f));
       m_MovingPointSetNode->SetVisibility(true);
       m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       this->clearTransformationLists();
       this->OpacityUpdate(m_Opacity);
     }
     if (m_MovingPointSetNode.IsNull())
     {
       m_MovingLandmarks = mitk::PointSet::New();
       m_MovingPointSetNode = mitk::DataNode::New();
       m_MovingPointSetNode->SetData(m_MovingLandmarks);
       m_MovingPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
 
       m_MovingPointSetNode->GetStringProperty("label", m_OldMovingLabel);
       m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New("M "));
       m_MovingPointSetNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f));
       m_MovingPointSetNode->SetVisibility(true);
       m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
       this->GetDataStorage()->Add(m_MovingPointSetNode, m_MovingNode);
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     }
 
 
 
 
   }
   else
   {
     m_MovingNode = NULL;
     if (m_MovingPointSetNode.IsNotNull())
       m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
     m_MovingPointSetNode = NULL;
     m_MovingLandmarks = NULL;
     m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
     m_Controls.m_MovingLabel->hide();
     m_Controls.TextLabelMoving->hide();
     m_Controls.line1->hide();
     m_Controls.m_MovingPointListWidget->hide();
     m_Controls.m_OpacityLabel->hide();
     m_Controls.m_OpacitySlider->hide();
     m_Controls.label->hide();
     m_Controls.label_2->hide();
   }
   if(m_MovingLandmarks.IsNotNull())
     m_CurrentMovingLandmarksObserverID = m_MovingLandmarks->AddObserver(itk::ModifiedEvent(), m_MovingLandmarksChangedCommand);
 }
 
 void QmitkPointBasedRegistrationView::updateMovingLandmarksList()
 {
 //  mitk::PointSet* ps = mitk::PointSet::New();
 //  ps = dynamic_cast<mitk::PointSet*>(m_MovingPointSetNode->GetData());
 //  mitk::DataNode::Pointer tmpPtr = m_MovingPointSetNode;
 //  m_MovingLandmarks = 0;
 //  m_MovingLandmarks = (ps);
   m_MovingLandmarks = dynamic_cast<mitk::PointSet*>(m_MovingPointSetNode->GetData());
 //  m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);    //Workaround: m_MovingPointListWidget->m_PointListView->m_PointListModel loses the pointer on the pointsetnode
   this->checkLandmarkError();
   this->CheckCalculate();
 }
 
 void QmitkPointBasedRegistrationView::updateFixedLandmarksList()
 {
   m_FixedLandmarks = dynamic_cast<mitk::PointSet*>(m_FixedPointSetNode->GetData());
   this->checkLandmarkError();
   this->CheckCalculate();
 }
 
 void QmitkPointBasedRegistrationView::HideFixedImage(bool hide)
 {
   m_HideFixedImage = hide;
   if(m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetVisibility(!hide);
   }
   if (hide)
   {
     //this->reinitMovingClicked();
   }
   if (!m_HideMovingImage && !m_HideFixedImage)
   {
     //this->globalReinitClicked();
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPointBasedRegistrationView::HideMovingImage(bool hide)
 {
   m_HideMovingImage = hide;
   if(m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetVisibility(!hide);
   }
   if (hide)
   {
     //this->reinitFixedClicked();
   }
   if (!m_HideMovingImage && !m_HideFixedImage)
   {
     //this->globalReinitClicked();
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 bool QmitkPointBasedRegistrationView::CheckCalculate()
 {
   if((m_MovingPointSetNode.IsNull())||(m_FixedPointSetNode.IsNull()||m_FixedLandmarks.IsNull()||m_MovingLandmarks.IsNull()))
     return false;
   if(m_MovingNode==m_FixedNode)
     return false;
   return this->checkCalculateEnabled();
 }
 
 void QmitkPointBasedRegistrationView::UndoTransformation()
 {
   if(!m_UndoPointsGeometryList.empty())
   {
     itk::LightObject::Pointer lopointer = m_MovingLandmarks->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer movingLandmarksGeometry = dynamic_cast<mitk::BaseGeometry*>(lopointer.GetPointer());
     m_RedoPointsGeometryList.push_back(movingLandmarksGeometry.GetPointer());
     m_MovingLandmarks->SetGeometry(m_UndoPointsGeometryList.back());
     m_UndoPointsGeometryList.pop_back();
     //\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
     //is still pointing to the old one. Workaround: delete mapper
     m_MovingPointSetNode->SetMapper(1, NULL);
 
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     itk::LightObject::Pointer lopointer2 = movingData->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer movingGeometry = dynamic_cast<mitk::BaseGeometry*>(lopointer2.GetPointer());
     m_RedoGeometryList.push_back(movingGeometry.GetPointer());
     movingData->SetGeometry(m_UndoGeometryList.back());
     m_UndoGeometryList.pop_back();
     //\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
     //is still pointing to the old one. Workaround: delete mapper
     m_MovingNode->SetMapper(1, NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
 
     movingData->GetTimeGeometry()->Update();
     m_MovingLandmarks->GetTimeGeometry()->Update();
     m_Controls.m_RedoTransformation->setEnabled(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     this->checkLandmarkError();
   }
   if(!m_UndoPointsGeometryList.empty())
   {
     m_Controls.m_UndoTransformation->setEnabled(true);
   }
   else
   {
     m_Controls.m_UndoTransformation->setEnabled(false);
   }
 }
 
 void QmitkPointBasedRegistrationView::RedoTransformation()
 {
   if(!m_RedoPointsGeometryList.empty())
   {
     itk::LightObject::Pointer lopointer = m_MovingLandmarks->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer movingLandmarksGeometry = dynamic_cast<mitk::BaseGeometry*>(lopointer.GetPointer());
     m_UndoPointsGeometryList.push_back(movingLandmarksGeometry.GetPointer());
     m_MovingLandmarks->SetGeometry(m_RedoPointsGeometryList.back());
     m_RedoPointsGeometryList.pop_back();
     //\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
     //is still pointing to the old one. Workaround: delete mapper
     m_MovingPointSetNode->SetMapper(1, NULL);
 
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     itk::LightObject::Pointer lopointer2 = movingData->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer movingGeometry = dynamic_cast<mitk::BaseGeometry*>(lopointer2.GetPointer());
     m_UndoGeometryList.push_back(movingGeometry.GetPointer());
     movingData->SetGeometry(m_RedoGeometryList.back());
     m_RedoGeometryList.pop_back();
     //\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
     //is still pointing to the old one. Workaround: delete mapper
     m_MovingNode->SetMapper(1, NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
 
     movingData->GetTimeGeometry()->Update();
     m_MovingLandmarks->GetTimeGeometry()->Update();
     m_Controls.m_UndoTransformation->setEnabled(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     this->checkLandmarkError();
   }
   if(!m_RedoPointsGeometryList.empty())
   {
     m_Controls.m_RedoTransformation->setEnabled(true);
   }
   else
   {
     m_Controls.m_RedoTransformation->setEnabled(false);
   }
 }
 
 void QmitkPointBasedRegistrationView::showRedGreen(bool redGreen)
 {
   m_ShowRedGreen = redGreen;
   this->setImageColor(m_ShowRedGreen);
 }
 
 void QmitkPointBasedRegistrationView::setImageColor(bool redGreen)
 {
   if (!redGreen && m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetColor(m_FixedColor);
   }
   if (!redGreen && m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetColor(m_MovingColor);
   }
   if (redGreen && m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
   }
   if (redGreen && m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPointBasedRegistrationView::OpacityUpdate(float opacity)
 {
   if (opacity > 1)
   {
     opacity = opacity/100.0f;
   }
   m_Opacity = opacity;
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_Opacity);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPointBasedRegistrationView::OpacityUpdate(int opacity)
 {
   float fValue = ((float)opacity)/100.0f;
   this->OpacityUpdate(fValue);
 }
 
 void QmitkPointBasedRegistrationView::clearTransformationLists()
 {
   m_Controls.m_UndoTransformation->setEnabled(false);
   m_Controls.m_RedoTransformation->setEnabled(false);
   m_Controls.m_MeanErrorLCD->hide();
   m_Controls.m_MeanError->hide();
   m_UndoGeometryList.clear();
   m_UndoPointsGeometryList.clear();
   m_RedoGeometryList.clear();
   m_RedoPointsGeometryList.clear();
 }
 
 void QmitkPointBasedRegistrationView::checkLandmarkError()
 {
   double totalDist = 0, dist = 0, dist2 = 0;
   mitk::Point3D point1, point2, point3;
   double p1[3], p2[3];
   if(m_Transformation < 3)
   {
     if (m_Controls.m_UseICP->isChecked())
     {
       if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull()&& m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0)
       {
         for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
         {
           point1 = m_MovingLandmarks->GetPoint(pointId);
           point2 = m_FixedLandmarks->GetPoint(0);
           p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
           p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
           dist = vtkMath::Distance2BetweenPoints(p1, p2);
           for(int pointId2 = 1; pointId2 < m_FixedLandmarks->GetSize(); ++pointId2)
           {
             point2 = m_FixedLandmarks->GetPoint(pointId2);
             p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = p1[2];
             p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = p2[2];
             dist2 = vtkMath::Distance2BetweenPoints(p1, p2);
             if (dist2 < dist)
             {
               dist = dist2;
             }
           }
           totalDist += dist;
         }
         m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
         m_Controls.m_MeanErrorLCD->show();
         m_Controls.m_MeanError->show();
       }
       else
       {
         m_Controls.m_MeanErrorLCD->hide();
         m_Controls.m_MeanError->hide();
       }
     }
     else
     {
       if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0 && m_MovingLandmarks->GetSize() == m_FixedLandmarks->GetSize())
       {
         for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
         {
           point1 = m_MovingLandmarks->GetPoint(pointId);
           point2 = m_FixedLandmarks->GetPoint(pointId);
           p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
           p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
           totalDist += vtkMath::Distance2BetweenPoints(p1, p2);
         }
         m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
         m_Controls.m_MeanErrorLCD->show();
         m_Controls.m_MeanError->show();
       }
       else
       {
         m_Controls.m_MeanErrorLCD->hide();
         m_Controls.m_MeanError->hide();
       }
     }
   }
   else
   {
     if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0 && m_MovingLandmarks->GetSize() == m_FixedLandmarks->GetSize())
     {
       for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
       {
         point1 = m_MovingLandmarks->GetPoint(pointId);
         point2 = m_FixedLandmarks->GetPoint(pointId);
         p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
         p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
         totalDist += vtkMath::Distance2BetweenPoints(p1, p2);
       }
       m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
       m_Controls.m_MeanErrorLCD->show();
       m_Controls.m_MeanError->show();
     }
     else
     {
       m_Controls.m_MeanErrorLCD->hide();
       m_Controls.m_MeanError->hide();
     }
   }
 }
 
 void QmitkPointBasedRegistrationView::transformationChanged(int transform)
 {
   m_Transformation = transform;
   this->checkCalculateEnabled();
   this->checkLandmarkError();
 }
 
 // ICP with vtkLandmarkTransformation
 void QmitkPointBasedRegistrationView::calculateLandmarkbasedWithICP()
 {
   if(CheckCalculate())
   {
     mitk::BaseGeometry::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
     itk::LightObject::Pointer lopointer = m_MovingLandmarks->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer movingLandmarksGeometry = dynamic_cast<mitk::BaseGeometry*>(lopointer.GetPointer());
     m_UndoPointsGeometryList.push_back(movingLandmarksGeometry.GetPointer());
 
     mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
     itk::LightObject::Pointer lopointer2 = originalData->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer originalDataGeometry = dynamic_cast<mitk::BaseGeometry*>(lopointer2.GetPointer());
     m_UndoGeometryList.push_back(originalDataGeometry.GetPointer());
 
     vtkIdType pointId;
     vtkPoints* vPointsSource=vtkPoints::New();
     vtkCellArray* vCellsSource=vtkCellArray::New();
     for(pointId=0; pointId<m_MovingLandmarks->GetSize();++pointId)
     {
       mitk::Point3D pointSource=m_MovingLandmarks->GetPoint(pointId);
       vPointsSource->InsertNextPoint(pointSource[0],pointSource[1],pointSource[2]);
       vCellsSource->InsertNextCell(1, &pointId);
     }
 
     vtkPoints* vPointsTarget=vtkPoints::New();
     vtkCellArray* vCellsTarget = vtkCellArray::New();
     for(pointId=0; pointId<m_FixedLandmarks->GetSize();++pointId)
     {
       mitk::Point3D pointTarget=m_FixedLandmarks->GetPoint(pointId);
       vPointsTarget->InsertNextPoint(pointTarget[0],pointTarget[1],pointTarget[2]);
       vCellsTarget->InsertNextCell(1, &pointId);
     }
 
     vtkPolyData* vPointSetSource=vtkPolyData::New();
     vtkPolyData* vPointSetTarget=vtkPolyData::New();
 
     vPointSetTarget->SetPoints(vPointsTarget);
     vPointSetTarget->SetVerts(vCellsTarget);
     vPointSetSource->SetPoints(vPointsSource);
     vPointSetSource->SetVerts(vCellsSource);
 
     vtkIterativeClosestPointTransform * icp=vtkIterativeClosestPointTransform::New();
     icp->SetCheckMeanDistance(1);
     icp->SetSource(vPointSetSource);
     icp->SetTarget(vPointSetTarget);
     icp->SetMaximumNumberOfIterations(50);
     icp->StartByMatchingCentroidsOn();
     vtkLandmarkTransform * transform=icp->GetLandmarkTransform();
     if(m_Transformation==0)
     {
       transform->SetModeToRigidBody();
     }
     if(m_Transformation==1)
     {
       transform->SetModeToSimilarity();
     }
     if(m_Transformation==2)
     {
       transform->SetModeToAffine();
     }
 
     vtkMatrix4x4 * matrix=icp->GetMatrix();
 
     double determinant = fabs(matrix->Determinant());
     if((determinant < mitk::eps) || (determinant > 100) || (determinant < 0.01)
       || (determinant==itk::NumericTraits<double>::infinity())
       || (determinant==itk::NumericTraits<double>::quiet_NaN())
       || (determinant==itk::NumericTraits<double>::signaling_NaN())
       || (determinant==-itk::NumericTraits<double>::infinity())
       || (determinant==-itk::NumericTraits<double>::quiet_NaN())
       || (determinant==-itk::NumericTraits<double>::signaling_NaN())
       || (!(determinant <= 0) && !(determinant > 0)))
     {
       QMessageBox msgBox;
       msgBox.setText("Suspicious determinant of matrix calculated by ICP.\n"
         "Please select more points or other points!" );
       msgBox.exec();
       return;
     }
 
     pointsGeometry->Compose(matrix);
     m_MovingLandmarks->GetTimeGeometry()->Update();
 
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     mitk::BaseGeometry::Pointer movingGeometry = movingData->GetGeometry(0);
     movingGeometry->Compose(matrix);
     movingData->GetTimeGeometry()->Update();
     m_Controls.m_UndoTransformation->setEnabled(true);
     m_Controls.m_RedoTransformation->setEnabled(false);
     m_RedoGeometryList.clear();
     m_RedoPointsGeometryList.clear();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     this->checkLandmarkError();
   }
 }
 
 // only vtkLandmarkTransformation
 void QmitkPointBasedRegistrationView::calculateLandmarkbased()
 {
   if(CheckCalculate())
   {
     mitk::BaseGeometry::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
     itk::LightObject::Pointer lopointer = m_MovingLandmarks->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer movingLandmarksGeometry =  dynamic_cast<mitk::BaseGeometry*>(lopointer.GetPointer());
     m_UndoPointsGeometryList.push_back(movingLandmarksGeometry.GetPointer());
 
     mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
     itk::LightObject::Pointer lopointer2 = originalData->GetGeometry(0)->Clone();
     mitk::BaseGeometry::Pointer originalDataGeometry =  dynamic_cast<mitk::BaseGeometry*>(lopointer2.GetPointer());
     m_UndoGeometryList.push_back(originalDataGeometry.GetPointer());
 
     vtkIdType pointId;
     vtkPoints* vPointsSource=vtkPoints::New();
     for(pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
     {
       mitk::Point3D sourcePoint = m_MovingLandmarks->GetPoint(pointId);
       vPointsSource->InsertNextPoint(sourcePoint[0],sourcePoint[1],sourcePoint[2]);
     }
     vtkPoints* vPointsTarget=vtkPoints::New();
     for(pointId=0; pointId<m_FixedLandmarks->GetSize();++pointId)
     {
       mitk::Point3D targetPoint=m_FixedLandmarks->GetPoint(pointId);
       vPointsTarget->InsertNextPoint(targetPoint[0],targetPoint[1],targetPoint[2]);
     }
 
     vtkLandmarkTransform * transform= vtkLandmarkTransform::New();
     transform->SetSourceLandmarks(vPointsSource);
     transform->SetTargetLandmarks(vPointsTarget);
     if(m_Transformation==0)
     {
       transform->SetModeToRigidBody();
     }
     if(m_Transformation==1)
     {
       transform->SetModeToSimilarity();
     }
     if(m_Transformation==2)
     {
       transform->SetModeToAffine();
     }
     vtkMatrix4x4 * matrix=transform->GetMatrix();
     double determinant = fabs(matrix->Determinant());
     if((determinant < mitk::eps) || (determinant > 100) || (determinant < 0.01)
       || (determinant==itk::NumericTraits<double>::infinity())
       || (determinant==itk::NumericTraits<double>::quiet_NaN())
       || (determinant==itk::NumericTraits<double>::signaling_NaN())
       || (determinant==-itk::NumericTraits<double>::infinity())
       || (determinant==-itk::NumericTraits<double>::quiet_NaN())
       || (determinant==-itk::NumericTraits<double>::signaling_NaN())
       || (!(determinant <= 0) && !(determinant > 0)))
     {
       QMessageBox msgBox;
       msgBox.setText("Suspicious determinant of matrix calculated.\n"
         "Please select more points or other points!" );
       msgBox.exec();
       return;
     }
     pointsGeometry->Compose(matrix);
     m_MovingLandmarks->GetTimeGeometry()->Update();
 
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     mitk::BaseGeometry::Pointer movingGeometry = movingData->GetGeometry(0);
     movingGeometry->Compose(matrix);
     movingData->GetTimeGeometry()->Update();
     m_Controls.m_UndoTransformation->setEnabled(true);
     m_Controls.m_RedoTransformation->setEnabled(false);
     m_RedoGeometryList.clear();
     m_RedoPointsGeometryList.clear();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     this->checkLandmarkError();
   }
 }
 
 void QmitkPointBasedRegistrationView::calculateLandmarkWarping()
 {
   mitk::LandmarkWarping* registration = new mitk::LandmarkWarping();
 
   mitk::LandmarkWarping::FixedImageType::Pointer fixedImage = mitk::LandmarkWarping::FixedImageType::New();
   mitk::Image::Pointer fimage = dynamic_cast<mitk::Image*>(m_FixedNode->GetData());
   mitk::LandmarkWarping::MovingImageType::Pointer movingImage = mitk::LandmarkWarping::MovingImageType::New();
   mitk::Image::Pointer mimage = dynamic_cast<mitk::Image*>(m_MovingNode->GetData());
   if (fimage.IsNotNull() && /*fimage->GetDimension() == 2 || */ fimage->GetDimension() == 3 && mimage.IsNotNull() && mimage->GetDimension() == 3)
   {
     mitk::CastToItkImage(fimage, fixedImage);
     mitk::CastToItkImage(mimage, movingImage);
 
     registration->SetFixedImage(fixedImage);
     registration->SetMovingImage(movingImage);
     unsigned int pointId;
     mitk::Point3D sourcePoint, targetPoint;
     mitk::LandmarkWarping::LandmarkContainerType::Pointer fixedLandmarks = mitk::LandmarkWarping::LandmarkContainerType::New();
     mitk::LandmarkWarping::LandmarkPointType point;
     for(pointId = 0; pointId < (unsigned int)m_FixedLandmarks->GetSize(); ++pointId)
     {
       fimage->GetGeometry(0)->WorldToItkPhysicalPoint(m_FixedLandmarks->GetPoint(pointId), point);
       fixedLandmarks->InsertElement( pointId, point);
     }
     mitk::LandmarkWarping::LandmarkContainerType::Pointer movingLandmarks = mitk::LandmarkWarping::LandmarkContainerType::New();
     for(pointId = 0; pointId < (unsigned int)m_MovingLandmarks->GetSize(); ++pointId)
     {
       mitk::BaseData::Pointer fixedData = m_FixedNode->GetData();
       mitk::BaseGeometry::Pointer fixedGeometry = fixedData->GetGeometry(0);
       fixedGeometry->WorldToItkPhysicalPoint(m_MovingLandmarks->GetPoint(pointId), point);
       movingLandmarks->InsertElement( pointId, point);
     }
     registration->SetLandmarks(fixedLandmarks.GetPointer(), movingLandmarks.GetPointer());
     mitk::LandmarkWarping::MovingImageType::Pointer output = registration->Register();
     if (output.IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       mitk::CastToMitkImage(output, image);
       m_MovingNode->SetData(image);
       mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
       mitk::LevelWindow levelWindow;
       levelWindow.SetAuto( image );
       levWinProp->SetLevelWindow(levelWindow);
       m_MovingNode->GetPropertyList()->SetProperty("levelwindow",levWinProp);
       movingLandmarks = registration->GetTransformedTargetLandmarks();
       mitk::PointSet::PointDataIterator it;
       it = m_MovingLandmarks->GetPointSet()->GetPointData()->Begin();
       //increase the eventId to encapsulate the coming operations
       mitk::OperationEvent::IncCurrObjectEventId();
       mitk::OperationEvent::ExecuteIncrement();
       for(pointId=0; pointId<movingLandmarks->Size();++pointId, ++it)
       {
         int position = it->Index();
         mitk::PointSet::PointType pt = m_MovingLandmarks->GetPoint(position);
         mitk::Point3D undoPoint = ( pt );
         point = movingLandmarks->GetElement(pointId);
         fimage->GetGeometry(0)->ItkPhysicalPointToWorld(point, pt);
         mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVE, pt, position);
         //undo operation
         mitk::PointOperation* undoOp = new mitk::PointOperation(mitk::OpMOVE, undoPoint, position);
         mitk::OperationEvent* operationEvent = new mitk::OperationEvent(m_MovingLandmarks, doOp, undoOp, "Move point");
         mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(operationEvent);
 
         //execute the Operation
         m_MovingLandmarks->ExecuteOperation(doOp);
       }
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       this->clearTransformationLists();
       this->checkLandmarkError();
     }
   }
 }
 
 bool QmitkPointBasedRegistrationView::checkCalculateEnabled()
 {
   if (m_FixedLandmarks.IsNotNull() && m_MovingLandmarks.IsNotNull())
   {
     int fixedPoints = m_FixedLandmarks->GetSize();
     int movingPoints = m_MovingLandmarks->GetSize();
     if (m_Transformation == 0 || m_Transformation == 1 || m_Transformation == 2)
     {
       if (m_Controls.m_UseICP->isChecked())
       {
         if((movingPoints > 0 && fixedPoints > 0))
         {
           m_Controls.m_Calculate->setEnabled(true);
           return true;
         }
         else
         {
           m_Controls.m_Calculate->setEnabled(false);
           return false;
         }
       }
       else
       {
         if ((movingPoints == fixedPoints) && movingPoints > 0)
         {
           m_Controls.m_Calculate->setEnabled(true);
           return true;
         }
         else
         {
           m_Controls.m_Calculate->setEnabled(false);
           return false;
         }
       }
     }
     else
     {
       m_Controls.m_Calculate->setEnabled(true);
       return true;
     }
   }
   else
   {
     return false;
   }
 }
 
 void QmitkPointBasedRegistrationView::calculate()
 {
   if (m_Transformation == 0 || m_Transformation == 1 || m_Transformation == 2)
   {
     if (m_Controls.m_UseICP->isChecked())
     {
       if (m_MovingLandmarks->GetSize() == 1 && m_FixedLandmarks->GetSize() == 1)
       {
         this->calculateLandmarkbased();
       }
       else
       {
         this->calculateLandmarkbasedWithICP();
       }
     }
     else
     {
       this->calculateLandmarkbased();
     }
   }
   else
   {
     this->calculateLandmarkWarping();
   }
 }
 
 void QmitkPointBasedRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
 {
   if (this->m_CurrentSelection->Size() == 0)
   {
     // show all images
     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
     {
-      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
+      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::PlaneGeometryData*>(nodeIt->Value()->GetData())==NULL)
       {
         nodeIt->Value()->SetVisibility(true);
       }
     }
   }
   else
   {
     // hide all images
     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
     {
-      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
+      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::PlaneGeometryData*>(nodeIt->Value()->GetData())==NULL)
       {
         nodeIt->Value()->SetVisibility(false);
       }
     }
   }
 }
 
 void QmitkPointBasedRegistrationView::SwitchImages()
 {
   mitk::DataNode::Pointer newMoving = m_FixedNode;
   mitk::DataNode::Pointer newFixed = m_MovingNode;
   this->FixedSelected(newFixed);
   this->MovingSelected(newMoving);
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
index eedf572147..a09be60d72 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
@@ -1,1456 +1,1456 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk includes
 #include "QmitkRigidRegistrationView.h"
 #include "QmitkStdMultiWidget.h"
 
 // MITK includes
 #include "mitkDataNodeObject.h"
 #include <mitkImageCast.h>
 #include "mitkManualSegmentationToSurfaceFilter.h"
 #include <mitkSegmentationSink.h>
 #include <mitkImageStatisticsHolder.h>
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateProperty.h"
 
 // QT includes
 #include "qinputdialog.h"
 #include "qmessagebox.h"
 #include "qcursor.h"
 #include "qapplication.h"
 #include "qradiobutton.h"
 #include "qslider.h"
 #include "qtooltip.h"
 
 // VTK includes
 #include <vtkTransform.h>
 
 // ITK includes
 #include <itkBinaryThresholdImageFilter.h>
 
 // BlueBerry includes
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 const std::string QmitkRigidRegistrationView::VIEW_ID = "org.mitk.views.rigidregistration";
 
 using namespace berry;
 
 struct SelListenerRigidRegistration : ISelectionListener
 {
   berryObjectMacro(SelListenerRigidRegistration);
 
   SelListenerRigidRegistration(QmitkRigidRegistrationView* view)
   {
     m_View = view;
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     // do something with the selected items
     if(m_View->m_CurrentSelection)
     {
       if (m_View->m_CurrentSelection->Size() != 2)
       {
         if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
         {
           m_View->m_Controls.m_StatusLabel->show();
           m_View->m_Controls.TextLabelFixed->hide();
           m_View->m_Controls.m_FixedLabel->hide();
           m_View->m_Controls.TextLabelMoving->hide();
           m_View->m_Controls.m_MovingLabel->hide();
           m_View->m_Controls.m_UseMaskingCB->hide();
           m_View->m_Controls.m_OpacityLabel->setEnabled(false);
           m_View->m_Controls.m_OpacitySlider->setEnabled(false);
           m_View->m_Controls.label->setEnabled(false);
           m_View->m_Controls.label_2->setEnabled(false);
           m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
           m_View->m_Controls.m_SwitchImages->hide();
         }
       }
       else
       {
         m_View->m_Controls.m_StatusLabel->hide();
         bool foundFixedImage = false;
         mitk::DataNode::Pointer fixedNode;
         // iterate selection
         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
           i != m_View->m_CurrentSelection->End(); ++i)
         {
           // extract datatree node
           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
           {
             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
             // only look at interesting types
             if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
             {
               if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 4)
               {
                 m_View->m_Controls.m_StatusLabel->show();
                 QMessageBox::information( NULL, "RigidRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
                 return;
               }
               if (foundFixedImage == false)
               {
                 fixedNode = node;
                 foundFixedImage = true;
               }
               else
               {
                 // m_View->SetImagesVisible(selection);
                 m_View->FixedSelected(fixedNode);
                 m_View->MovingSelected(node);
                 m_View->m_Controls.m_StatusLabel->hide();
                 m_View->m_Controls.TextLabelFixed->show();
                 m_View->m_Controls.m_FixedLabel->show();
                 m_View->m_Controls.TextLabelMoving->show();
                 m_View->m_Controls.m_MovingLabel->show();
                 m_View->m_Controls.m_UseMaskingCB->show();
                 m_View->m_Controls.m_OpacityLabel->setEnabled(true);
                 m_View->m_Controls.m_OpacitySlider->setEnabled(true);
                 m_View->m_Controls.label->setEnabled(true);
                 m_View->m_Controls.label_2->setEnabled(true);
                 m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
               }
             }
             else
             {
               m_View->m_Controls.m_StatusLabel->show();
               return;
             }
           }
         }
       }
     }
     else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
     {
       m_View->m_Controls.m_StatusLabel->show();
     }
   }
 
   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname(part->GetPartName().c_str());
       if(partname.compare("Data Manager")==0)
       {
         // apply selection
         DoSelectionChanged(selection);
       }
     }
   }
 
   QmitkRigidRegistrationView* m_View;
 };
 
 QmitkRigidRegistrationView::QmitkRigidRegistrationView(QObject * /*parent*/, const char * /*name*/)
 : QmitkFunctionality(), m_MultiWidget(NULL), m_MovingNode(NULL), m_MovingMaskNode(NULL), m_FixedNode(NULL), m_FixedMaskNode(NULL),
 m_ShowRedGreen(false), m_Opacity(0.5), m_OriginalOpacity(1.0), m_Deactivated(false),m_FixedDimension(0), m_MovingDimension(0)
 {
   m_TranslateSliderPos[0] = 0;
   m_TranslateSliderPos[1] = 0;
   m_TranslateSliderPos[2] = 0;
 
   m_RotateSliderPos[0] = 0;
   m_RotateSliderPos[1] = 0;
   m_RotateSliderPos[2] = 0;
 
   m_ScaleSliderPos[0] = 0;
   m_ScaleSliderPos[1] = 0;
   m_ScaleSliderPos[2] = 0;
 
   translationParams = new int[3];
   rotationParams = new int[3];
   scalingParams = new int[3];
 
   m_TimeStepperAdapter = NULL;
 
   this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkRigidRegistrationView,
     const mitk::DataNode*> ( this, &QmitkRigidRegistrationView::DataNodeHasBeenRemoved ));
 }
 
 QmitkRigidRegistrationView::~QmitkRigidRegistrationView()
 {
   if(m_SelListener.IsNotNull())
   {
     berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
     if(s)
       s->RemovePostSelectionListener(m_SelListener);
     m_SelListener = NULL;
   }
 
   this->GetDataStorage()->RemoveNodeEvent.RemoveListener(mitk::MessageDelegate1<QmitkRigidRegistrationView,
     const mitk::DataNode*> ( this, &QmitkRigidRegistrationView::DataNodeHasBeenRemoved ));
 }
 
 void QmitkRigidRegistrationView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.m_ManualFrame->hide();
   m_Controls.timeSlider->hide();
   m_Controls.TextLabelFixed->hide();
   m_Controls.m_FixedLabel->hide();
   m_Controls.TextLabelMoving->hide();
   m_Controls.m_MovingLabel->hide();
   //m_Controls.m_UseFixedImageMask->hide();
   //m_Controls.m_UseMovingImageMask->hide();
   m_Controls.m_UseMaskingCB->hide();
   m_Controls.m_OpacityLabel->setEnabled(false);
   m_Controls.m_OpacitySlider->setEnabled(false);
   m_Controls.label->setEnabled(false);
   m_Controls.label_2->setEnabled(false);
   m_Controls.m_ShowRedGreenValues->setEnabled(false);
   m_Controls.m_SwitchImages->hide();
   if (m_Controls.m_RigidTransform->currentIndex() == 1)
   {
     m_Controls.frame->show();
   }
   else
   {
     m_Controls.frame->hide();
   }
   m_Controls.m_ManualFrame->setEnabled(false);
   m_Parent->setEnabled(false);
 
   mitk::NodePredicateAnd::Pointer andPred =                       // we want binary images in the selectors
     mitk::NodePredicateAnd::New(mitk::NodePredicateDataType::New("Image"),
     mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true)));
 
   m_Controls.m_FixedImageCB->SetPredicate(andPred);
   m_Controls.m_FixedImageCB->SetDataStorage(this->GetDataStorage());
   m_Controls.m_FixedImageCB->hide();
   m_Controls.m_FixedMaskLB->hide();
 
   m_Controls.m_MovingImageCB->SetPredicate(andPred);
   m_Controls.m_MovingImageCB->SetDataStorage(this->GetDataStorage());
   m_Controls.m_MovingImageCB->hide();
   m_Controls.m_MovingMaskLB->hide();
 
   this->CreateConnections();
   this->CheckCalculateEnabled();
 }
 
 void QmitkRigidRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_Parent->setEnabled(true);
   m_MultiWidget = &stdMultiWidget;
   m_MultiWidget->SetWidgetPlanesVisibility(true);
 }
 
 void QmitkRigidRegistrationView::StdMultiWidgetNotAvailable()
 {
   m_Parent->setEnabled(false);
   m_MultiWidget = NULL;
 }
 
 void QmitkRigidRegistrationView::CreateConnections()
 {
   connect( m_Controls.m_ManualRegistrationCheckbox, SIGNAL(toggled(bool)), this, SLOT(ShowManualRegistrationFrame(bool)));
   connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
   connect(m_Controls.m_ShowRedGreenValues, SIGNAL(toggled(bool)), this, SLOT(ShowRedGreen(bool)));
   connect(m_Controls.m_ShowContour, SIGNAL(toggled(bool)), this, SLOT(EnableContour(bool)));
   //connect(m_Controls.m_UseFixedImageMask, SIGNAL(toggled(bool)), this, SLOT(UseFixedMaskImageChecked(bool)));
   //connect(m_Controls.m_UseMovingImageMask, SIGNAL(toggled(bool)), this, SLOT(UseMovingMaskImageChecked(bool)));
   connect(m_Controls.m_RigidTransform, SIGNAL(currentChanged(int)), this, SLOT(TabChanged(int)));
   connect(m_Controls.m_OpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityUpdate(int)));
   connect(m_Controls.m_ContourSlider, SIGNAL(sliderReleased()), this, SLOT(ShowContour()));
 
   connect(m_Controls.m_CalculateTransformation, SIGNAL(clicked()), this, SLOT(Calculate()));
   connect(m_Controls.m_UndoTransformation,SIGNAL(clicked()),this,SLOT(UndoTransformation()));
   connect(m_Controls.m_RedoTransformation,SIGNAL(clicked()),this,SLOT(RedoTransformation()));
   connect(m_Controls.m_AutomaticTranslation,SIGNAL(clicked()),this,SLOT(AlignCenters()));
   connect(m_Controls.m_StopOptimization,SIGNAL(clicked()), this , SLOT(StopOptimizationClicked()));
   connect(m_Controls.m_XTransSlider, SIGNAL(valueChanged(int)), this, SLOT(xTrans_valueChanged(int)));
   connect(m_Controls.m_YTransSlider, SIGNAL(valueChanged(int)), this, SLOT(yTrans_valueChanged(int)));
   connect(m_Controls.m_ZTransSlider, SIGNAL(valueChanged(int)), this, SLOT(zTrans_valueChanged(int)));
   connect(m_Controls.m_XRotSlider, SIGNAL(valueChanged(int)), this, SLOT(xRot_valueChanged(int)));
   connect(m_Controls.m_YRotSlider, SIGNAL(valueChanged(int)), this, SLOT(yRot_valueChanged(int)));
   connect(m_Controls.m_ZRotSlider, SIGNAL(valueChanged(int)), this, SLOT(zRot_valueChanged(int)));
   connect(m_Controls.m_XScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(xScale_valueChanged(int)));
   connect(m_Controls.m_YScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(yScale_valueChanged(int)));
   connect(m_Controls.m_ZScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(zScale_valueChanged(int)));
   connect(m_Controls.m_LoadRigidRegistrationParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(LoadRigidRegistrationParameter()));
   connect(m_Controls.m_SaveRigidRegistrationParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(SaveRigidRegistrationParameter()));
   connect(m_Controls.m_LoadRigidRegistrationTestParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(LoadRigidRegistrationTestParameter()));
   connect(m_Controls.m_SaveRigidRegistrationTestParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(SaveRigidRegistrationTestParameter()));
   connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(OptimizerChanged(double)),this,SLOT(SetOptimizerValue( double )));
   connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(TransformChanged()),this,SLOT(CheckCalculateEnabled()));
   connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(AddNewTransformationToUndoList()),this,SLOT(AddNewTransformationToUndoList()));
   connect(m_Controls.m_UseMaskingCB, SIGNAL(stateChanged(int)),this,SLOT(OnUseMaskingChanged(int)));
   connect(m_Controls.m_FixedImageCB, SIGNAL(OnSelectionChanged(const mitk::DataNode*)),this,SLOT(OnFixedMaskImageChanged(const mitk::DataNode*)));
   connect(m_Controls.m_MovingImageCB, SIGNAL(OnSelectionChanged(const mitk::DataNode*)),this,SLOT(OnMovingMaskImageChanged(const mitk::DataNode*)));
 }
 
 void QmitkRigidRegistrationView::Activated()
 {
   m_Deactivated = false;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Activated();
   if (m_SelListener.IsNull())
   {
     m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
     berry::ISelection::ConstPointer sel(
       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
     m_CurrentSelection = sel.Cast<const IStructuredSelection>();
     m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
   }
   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
   this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
   this->ClearTransformationLists();
   this->CheckCalculateEnabled();
   /*
   m_Deactivated = false;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Activated();
   if (m_SelListener.IsNull())
   {
   m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/ *"org.mitk.views.datamanager",* / m_SelListener);
   berry::ISelection::ConstPointer sel(
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
   }
   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
   this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
   this->ClearTransformationLists();
   this->CheckCalculateEnabled();*/
 }
 
 void QmitkRigidRegistrationView::Visible()
 {
   /*
   m_Deactivated = false;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Activated();
   if (m_SelListener.IsNull())
   {
   m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener("org.mitk.views.datamanager", m_SelListener);
   berry::ISelection::ConstPointer sel(
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
   }
   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
   this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
   this->ClearTransformationLists();
   this->CheckCalculateEnabled();*/
 }
 
 void QmitkRigidRegistrationView::Deactivated()
 {
   m_Deactivated = true;
   this->SetImageColor(false);
   if (m_FixedNode.IsNotNull())
     m_FixedNode->SetOpacity(1.0);
   m_FixedNode = NULL;
   m_MovingNode = NULL;
   this->ClearTransformationLists();
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
     s->RemovePostSelectionListener(m_SelListener);
   m_SelListener = NULL;
   /*
   m_Deactivated = true;
   this->SetImageColor(false);
   m_FixedNode = NULL;
   m_MovingNode = NULL;
   this->ClearTransformationLists();
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
   s->RemovePostSelectionListener(m_SelListener);
   m_SelListener = NULL;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Deactivated();*/
 }
 
 void QmitkRigidRegistrationView::Hidden()
 {
   /*m_Deactivated = true;
   this->SetImageColor(false);
   m_FixedNode = NULL;
   m_MovingNode = NULL;
   this->ClearTransformationLists();
   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   if(s)
   s->RemovePostSelectionListener(m_SelListener);
   m_SelListener = NULL;
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   //QmitkFunctionality::Deactivated();*/
 }
 
 void QmitkRigidRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
 {
   if(node == m_FixedNode || node == m_MovingNode)
   {
     m_Controls.m_StatusLabel->show();
     m_Controls.TextLabelFixed->hide();
     m_Controls.m_FixedLabel->hide();
     m_Controls.TextLabelMoving->hide();
     m_Controls.m_MovingLabel->hide();
     m_Controls.m_OpacityLabel->setEnabled(false);
     m_Controls.m_OpacitySlider->setEnabled(false);
     m_Controls.label->setEnabled(false);
     m_Controls.label_2->setEnabled(false);
     m_Controls.m_ShowRedGreenValues->setEnabled(false);
     m_Controls.m_SwitchImages->hide();
   }
 
   else if(node == m_ContourHelperNode)
   {
     // can this cause a memory leak?
     m_ContourHelperNode = NULL;
   }
 }
 
 void QmitkRigidRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
 {
   if (m_FixedNode.IsNotNull())
   {
     this->SetImageColor(false);
     m_FixedNode->SetOpacity(1.0);
   }
   m_FixedNode = fixedImage;
   if (m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetOpacity(0.5);
     m_FixedNode->SetVisibility(true);
     m_Controls.TextLabelFixed->setText(QString::fromStdString(m_FixedNode->GetName()));
     m_Controls.m_FixedLabel->show();
     m_Controls.TextLabelFixed->show();
     m_Controls.m_SwitchImages->show();
     mitk::ColorProperty::Pointer colorProperty;
     colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
     if ( colorProperty.IsNotNull() )
     {
       m_FixedColor = colorProperty->GetColor();
     }
     this->SetImageColor(m_ShowRedGreen);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     if (dynamic_cast<mitk::Image*>(m_FixedNode->GetData()))
     {
       m_FixedDimension = dynamic_cast<mitk::Image*>(m_FixedNode->GetData())->GetDimension();
       m_Controls.qmitkRigidRegistrationSelector1->SetFixedDimension(m_FixedDimension);
       m_Controls.qmitkRigidRegistrationSelector1->SetFixedNode(m_FixedNode);
     }
 
     // what's about masking?
     m_Controls.m_UseMaskingCB->show();
 
     // Modify slider range
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_FixedNode->GetData());
     int min = (int)image->GetStatistics()->GetScalarValueMin();
     int max = (int)image->GetStatistics()->GetScalarValueMax();
     m_Controls.m_ContourSlider->setRange(min, max);
 
     // Set slider to a default value
     int avg = (min+max) / 2;
     m_Controls.m_ContourSlider->setSliderPosition(avg);
     m_Controls.m_ThresholdLabel->setText(QString::number(avg));
   }
   else
   {
     m_Controls.m_FixedLabel->hide();
     m_Controls.TextLabelFixed->hide();
     m_Controls.m_SwitchImages->hide();
   }
   this->CheckCalculateEnabled();
   if(this->GetActiveStdMultiWidget())
   {
     m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls.timeSlider, m_MultiWidget->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromRigidRegistration");
     connect( m_TimeStepperAdapter, SIGNAL( Refetch() ), this, SLOT( UpdateTimestep() ) );
   }
 }
 
 void QmitkRigidRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
 {
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_OriginalOpacity);
     if (m_FixedNode == m_MovingNode)
       m_FixedNode->SetOpacity(0.5);
     this->SetImageColor(false);
   }
   m_MovingNode = movingImage;
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetVisibility(true);
     m_Controls.TextLabelMoving->setText(QString::fromStdString(m_MovingNode->GetName()));
     m_Controls.m_MovingLabel->show();
     m_Controls.TextLabelMoving->show();
     mitk::ColorProperty::Pointer colorProperty;
     colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
     if ( colorProperty.IsNotNull() )
     {
       m_MovingColor = colorProperty->GetColor();
     }
     this->SetImageColor(m_ShowRedGreen);
     m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
     this->OpacityUpdate(m_Opacity);
 
     // what's about masking?
     m_Controls.m_UseMaskingCB->show();
   }
   else
   {
     m_Controls.m_MovingLabel->hide();
     m_Controls.TextLabelMoving->hide();
     m_Controls.m_UseMaskingCB->hide();
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->MovingImageChanged();
   this->CheckCalculateEnabled();
 }
 
 bool QmitkRigidRegistrationView::CheckCalculate()
 {
   if(m_MovingNode==m_FixedNode)
     return false;
   return true;
 }
 
 void QmitkRigidRegistrationView::AddNewTransformationToUndoList()
 {
   mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
   m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry()->Clone().GetPointer()));
 
   GeometryMapType childGeometries = GeometryMapType();
   if(m_MovingMaskNode.IsNotNull())
   {
     childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(m_MovingMaskNode,
       static_cast<mitk::Geometry3D *>(m_MovingMaskNode->GetData()->GetGeometry()->Clone().GetPointer())));
   }
 
   mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
   if(children.IsNotNull() && children->Size() != 0)
   {
     unsigned long size;
     size = children->Size();
     for (unsigned long i = 0; i < size; ++i)
     {
       childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(children->GetElement(i),
         static_cast<mitk::Geometry3D *>(children->GetElement(i)->GetData()->GetGeometry()->Clone().GetPointer())));
     }
   }
   m_UndoChildGeometryList.push_back(childGeometries);
   m_RedoGeometryList.clear();
   m_RedoChildGeometryList.clear();
   this->SetUndoEnabled(true);
   this->SetRedoEnabled(false);
 }
 
 void QmitkRigidRegistrationView::UndoTransformation()
 {
   if(!m_UndoGeometryList.empty())
   {
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     m_RedoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
 
     unsigned long size = 0;
     GeometryMapType childGeometries = GeometryMapType();
     if(m_MovingMaskNode.IsNotNull())
     {
       ++size;
     }
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     size += children->Size();
 
     for (unsigned long i = 0; i < size; ++i)
     {
       if(i==0)
       {
         childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(m_MovingMaskNode,
           static_cast<mitk::Geometry3D *>(m_MovingMaskNode->GetData()->GetGeometry()->Clone().GetPointer())));
       }
       else
       {
         childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(children->GetElement(i),
           static_cast<mitk::Geometry3D *>(children->GetElement(i)->GetData()->GetGeometry()->Clone().GetPointer())));
       }
     }
 
     m_RedoChildGeometryList.push_back(childGeometries);
 
     movingData->SetGeometry(m_UndoGeometryList.back());
     m_UndoGeometryList.pop_back();
     GeometryMapType oldChildGeometries;
     oldChildGeometries = m_UndoChildGeometryList.back();
     m_UndoChildGeometryList.pop_back();
 
     GeometryMapType::iterator iter;
     for (unsigned long j = 0; j < size; ++j)
     {
       if(j == 0)    // we have put the geometry for the moving mask at position one
       {
         iter = oldChildGeometries.find(m_MovingMaskNode);
         mitk::Geometry3D* geo = static_cast<mitk::Geometry3D*>((*iter).second);
         m_MovingMaskNode->GetData()->SetGeometry(geo);
         m_MovingMaskNode->GetData()->GetTimeGeometry()->Update();
       }
       else
       {
         iter = oldChildGeometries.find(children->GetElement(j));
         children->GetElement(j)->GetData()->SetGeometry((*iter).second);
       }
     }
 
     //\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
     //is still pointing to the old one. Workaround: delete mapper
 
     //m_MovingNode->SetMapper(1, NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     this->SetRedoEnabled(true);
   }
   if(!m_UndoGeometryList.empty())
   {
     this->SetUndoEnabled(true);
   }
   else
   {
     this->SetUndoEnabled(false);
   }
   this->CheckCalculateEnabled();
 }
 
 void QmitkRigidRegistrationView::RedoTransformation()
 {
   if(!m_RedoGeometryList.empty())
   {
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
 
     unsigned long size = 0;
     GeometryMapType childGeometries = GeometryMapType();
     if(m_MovingMaskNode.IsNotNull())
     {
       ++size;
     }
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     size += children->Size();
 
     for (unsigned long i = 0; i < size; ++i)
     {
       if(i == 0)
       {
         childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(m_MovingMaskNode,
           static_cast<mitk::Geometry3D *>(m_MovingMaskNode->GetData()->GetGeometry()->Clone().GetPointer())));
       }
       else
       {
         childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(children->GetElement(i),
           static_cast<mitk::Geometry3D *>(children->GetElement(i)->GetData()->GetGeometry()->Clone().GetPointer())));
       }
     }
 
     m_UndoChildGeometryList.push_back(childGeometries);
 
     movingData->SetGeometry(m_RedoGeometryList.back());
     m_RedoGeometryList.pop_back();
 
     GeometryMapType oldChildGeometries;
     oldChildGeometries = m_RedoChildGeometryList.back();
     m_RedoChildGeometryList.pop_back();
     GeometryMapType::iterator iter;
     for (unsigned long j = 0; j < size; ++j)
     {
       if(j == 0)
       {
         iter = oldChildGeometries.find(m_MovingMaskNode);
         m_MovingMaskNode->GetData()->SetGeometry((*iter).second);
       }
       else
       {
         iter = oldChildGeometries.find(children->GetElement(j));
         children->GetElement(j)->GetData()->SetGeometry((*iter).second);
       }
     }
 
     movingData->GetTimeGeometry()->Update();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     this->SetUndoEnabled(true);
   }
   if(!m_RedoGeometryList.empty())
   {
     this->SetRedoEnabled(true);
   }
   else
   {
     this->SetRedoEnabled(false);
   }
 }
 
 void QmitkRigidRegistrationView::ShowRedGreen(bool redGreen)
 {
   m_ShowRedGreen = redGreen;
   this->SetImageColor(m_ShowRedGreen);
 }
 
 void QmitkRigidRegistrationView::EnableContour(bool show)
 {
   if(show)
     ShowContour();
 
   // Can happen when the m_ContourHelperNode was deleted before and now the show contour checkbox is turned off
   if(m_ContourHelperNode.IsNull())
     return;
 
   m_Controls.m_ContourSlider->setEnabled(show);
   m_ContourHelperNode->SetProperty("visible", mitk::BoolProperty::New(show));
 
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 void QmitkRigidRegistrationView::ShowContour()
 {
   int threshold = m_Controls.m_ContourSlider->value();
 
   bool show = m_Controls.m_ShowContour->isChecked();
 
   if(m_FixedNode.IsNull() || !show)
     return;
 
 
   // Update the label next to the slider
   m_Controls.m_ThresholdLabel->setText(QString::number(threshold));
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_FixedNode->GetData());
 
   typedef itk::Image<float,3> FloatImageType;
   typedef itk::Image<short,3> ShortImageType;
 
   // Create a binary image using the given treshold
   typedef itk::BinaryThresholdImageFilter<FloatImageType, ShortImageType> ThresholdFilterType;
 
   FloatImageType::Pointer floatImage = FloatImageType::New();
   mitk::CastToItkImage(image, floatImage);
 
 
   ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
   thresholdFilter->SetInput(floatImage);
   thresholdFilter->SetLowerThreshold(threshold);
   thresholdFilter->SetUpperThreshold((int)image->GetStatistics()->GetScalarValueMax());
   thresholdFilter->SetInsideValue(1);
   thresholdFilter->SetOutsideValue(0);
   thresholdFilter->Update();
 
   ShortImageType::Pointer binaryImage = thresholdFilter->GetOutput();
   mitk::Image::Pointer mitkBinaryImage = mitk::Image::New();
   mitk::CastToMitkImage(binaryImage, mitkBinaryImage);
 
 
 
 
   // Create a contour from the binary image
   mitk::ManualSegmentationToSurfaceFilter::Pointer surfaceFilter = mitk::ManualSegmentationToSurfaceFilter::New();
   surfaceFilter->SetInput( mitkBinaryImage );
   surfaceFilter->SetThreshold( 1 ); //expects binary image with zeros and ones
   surfaceFilter->SetUseGaussianImageSmooth(false); // apply gaussian to thresholded image ?
   surfaceFilter->SetMedianFilter3D(false); // apply median to segmentation before marching cubes ?
   surfaceFilter->SetDecimate( mitk::ImageToSurfaceFilter::NoDecimation );
 
   surfaceFilter->UpdateLargestPossibleRegion();
 
   // calculate normals for nicer display
   mitk::Surface::Pointer surface = surfaceFilter->GetOutput();
 
 
   if(m_ContourHelperNode.IsNull())
   {
     m_ContourHelperNode = mitk::DataNode::New();
     m_ContourHelperNode->SetData(surface);
     m_ContourHelperNode->SetProperty("opacity", mitk::FloatProperty::New(1.0) );
     m_ContourHelperNode->SetProperty("line width", mitk::IntProperty::New(2) );
     m_ContourHelperNode->SetProperty("scalar visibility", mitk::BoolProperty::New(false) );
     m_ContourHelperNode->SetProperty( "name", mitk::StringProperty::New("surface") );
     m_ContourHelperNode->SetProperty("color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
     m_ContourHelperNode->SetBoolProperty("helper object", true);
     this->GetDataStorage()->Add(m_ContourHelperNode);
   }
   else
   {
     m_ContourHelperNode->SetData(surface);
   }
 
 
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 
 void QmitkRigidRegistrationView::SetImageColor(bool redGreen)
 {
   if (!redGreen && m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetColor(m_FixedColor);
   }
   if (!redGreen && m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetColor(m_MovingColor);
   }
   if (redGreen && m_FixedNode.IsNotNull())
   {
     m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
   }
   if (redGreen && m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkRigidRegistrationView::OpacityUpdate(float opacity)
 {
   m_Opacity = opacity;
   if (m_MovingNode.IsNotNull())
   {
     m_MovingNode->SetOpacity(m_Opacity);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkRigidRegistrationView::OpacityUpdate(int opacity)
 {
   float fValue = ((float)opacity)/100.0f;
   this->OpacityUpdate(fValue);
 }
 
 void QmitkRigidRegistrationView::ClearTransformationLists()
 {
   this->SetUndoEnabled(false);
   this->SetRedoEnabled(false);
   m_UndoGeometryList.clear();
   m_UndoChildGeometryList.clear();
   m_RedoGeometryList.clear();
   m_RedoChildGeometryList.clear();
 }
 
 void QmitkRigidRegistrationView::Translate(int* translateVector)
 {
   if (m_MovingNode.IsNotNull())
   {
     mitk::Vector3D translateVec;
 
     translateVec[0] = translateVector[0] - m_TranslateSliderPos[0];
     translateVec[1] = translateVector[1] - m_TranslateSliderPos[1];
     translateVec[2] = translateVector[2] - m_TranslateSliderPos[2];
 
     m_TranslateSliderPos[0] = translateVector[0];
     m_TranslateSliderPos[1] = translateVector[1];
     m_TranslateSliderPos[2] = translateVector[2];
 
     vtkMatrix4x4* translationMatrix = vtkMatrix4x4::New();
     translationMatrix->Identity();
 
     double (*transMatrix)[4] = translationMatrix->Element;
 
     transMatrix[0][3] = -translateVec[0];
     transMatrix[1][3] = -translateVec[1];
     transMatrix[2][3] = -translateVec[2];
 
     translationMatrix->Invert();
 
     m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
     m_MovingNode->GetData()->Modified();
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     unsigned long size;
     size = children->Size();
     mitk::DataNode::Pointer childNode;
     for (unsigned long i = 0; i < size; ++i)
     {
       childNode = children->GetElement(i);
       childNode->GetData()->GetGeometry()->Compose( translationMatrix );
       childNode->GetData()->Modified();
     }
     m_RedoGeometryList.clear();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkRigidRegistrationView::Rotate(int* rotateVector)
 {
   if (m_MovingNode.IsNotNull())
   {
     mitk::Vector3D rotateVec;
 
     rotateVec[0] = rotateVector[0] - m_RotateSliderPos[0];
     rotateVec[1] = rotateVector[1] - m_RotateSliderPos[1];
     rotateVec[2] = rotateVector[2] - m_RotateSliderPos[2];
 
     m_RotateSliderPos[0] = rotateVector[0];
     m_RotateSliderPos[1] = rotateVector[1];
     m_RotateSliderPos[2] = rotateVector[2];
 
     vtkMatrix4x4* rotationMatrix = vtkMatrix4x4::New();
     vtkMatrix4x4* translationMatrix = vtkMatrix4x4::New();
     rotationMatrix->Identity();
     translationMatrix->Identity();
 
     double (*rotMatrix)[4] = rotationMatrix->Element;
     double (*transMatrix)[4] = translationMatrix->Element;
 
     mitk::Point3D centerBB = m_MovingNode->GetData()->GetGeometry()->GetCenter();
 
     transMatrix[0][3] = centerBB[0];
     transMatrix[1][3] = centerBB[1];
     transMatrix[2][3] = centerBB[2];
 
     translationMatrix->Invert();
 
     m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     unsigned long size;
     size = children->Size();
     mitk::DataNode::Pointer childNode;
     for (unsigned long i = 0; i < size; ++i)
     {
       childNode = children->GetElement(i);
       childNode->GetData()->GetGeometry()->Compose( translationMatrix );
       childNode->GetData()->Modified();
     }
 
     double radianX = rotateVec[0] * vnl_math::pi / 180;
     double radianY = rotateVec[1] * vnl_math::pi / 180;
     double radianZ = rotateVec[2] * vnl_math::pi / 180;
 
     if ( rotateVec[0] != 0 )
     {
       rotMatrix[1][1] = cos( radianX );
       rotMatrix[1][2] = -sin( radianX );
       rotMatrix[2][1] = sin( radianX );
       rotMatrix[2][2] = cos( radianX );
     }
     else if ( rotateVec[1] != 0 )
     {
       rotMatrix[0][0] = cos( radianY );
       rotMatrix[0][2] = sin( radianY );
       rotMatrix[2][0] = -sin( radianY );
       rotMatrix[2][2] = cos( radianY );
     }
     else if ( rotateVec[2] != 0 )
     {
       rotMatrix[0][0] = cos( radianZ );
       rotMatrix[0][1] = -sin( radianZ );
       rotMatrix[1][0] = sin( radianZ );
       rotMatrix[1][1] = cos( radianZ );
     }
 
     m_MovingNode->GetData()->GetGeometry()->Compose( rotationMatrix );
     for (unsigned long i = 0; i < size; ++i)
     {
       childNode = children->GetElement(i);
       childNode->GetData()->GetGeometry()->Compose( rotationMatrix );
       childNode->GetData()->Modified();
     }
 
     translationMatrix->Invert();
 
     m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
     for (unsigned long i = 0; i < size; ++i)
     {
       childNode = children->GetElement(i);
       childNode->GetData()->GetGeometry()->Compose( rotationMatrix );
       childNode->GetData()->Modified();
     }
     m_MovingNode->GetData()->Modified();
     m_RedoGeometryList.clear();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkRigidRegistrationView::Scale(int* scaleVector)
 {
   if (m_MovingNode.IsNotNull())
   {
     mitk::Vector3D scaleVec;
 
     scaleVec[0] = scaleVector[0] - m_ScaleSliderPos[0];
     scaleVec[1] = scaleVector[1] - m_ScaleSliderPos[1];
     scaleVec[2] = scaleVector[2] - m_ScaleSliderPos[2];
 
     m_ScaleSliderPos[0] = scaleVector[0];
     m_ScaleSliderPos[1] = scaleVector[1];
     m_ScaleSliderPos[2] = scaleVector[2];
 
     vtkMatrix4x4* scalingMatrix = vtkMatrix4x4::New();
     scalingMatrix->Identity();
 
     double (*scaleMatrix)[4] = scalingMatrix->Element;
 
     if (scaleVec[0] >= 0)
     {
       for(int i = 0; i<scaleVec[0]; i++)
       {
         scaleMatrix[0][0] *= 0.95;
       }
     }
     else
     {
       for(int i = 0; i<-scaleVec[0]; i++)
       {
         scaleMatrix[0][0] *= 1/0.95;
       }
     }
 
     if (scaleVec[1] >= 0)
     {
       for(int i = 0; i<scaleVec[1]; i++)
       {
         scaleMatrix[1][1] *= 0.95;
       }
     }
     else
     {
       for(int i = 0; i<-scaleVec[1]; i++)
       {
         scaleMatrix[1][1] *= 1/0.95;
       }
     }
 
     if (scaleVec[2] >= 0)
     {
       for(int i = 0; i<scaleVec[2]; i++)
       {
         scaleMatrix[2][2] *= 0.95;
       }
     }
     else
     {
       for(int i = 0; i<-scaleVec[2]; i++)
       {
         scaleMatrix[2][2] *= 1/0.95;
       }
     }
 
     scalingMatrix->Invert();
 
     m_MovingNode->GetData()->GetGeometry()->Compose( scalingMatrix );
     m_MovingNode->GetData()->Modified();
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     unsigned long size;
     size = children->Size();
     mitk::DataNode::Pointer childNode;
     for (unsigned long i = 0; i < size; ++i)
     {
       childNode = children->GetElement(i);
       childNode->GetData()->GetGeometry()->Compose( scalingMatrix );
       childNode->GetData()->Modified();
     }
     m_RedoGeometryList.clear();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkRigidRegistrationView::AlignCenters()
 {
   if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
   {
     mitk::Point3D fixedPoint = m_FixedNode->GetData()->GetGeometry()->GetCenter();
     mitk::Point3D movingPoint = m_MovingNode->GetData()->GetGeometry()->GetCenter();
     mitk::Vector3D translateVec;
     translateVec =  fixedPoint - movingPoint;
     m_Controls.m_XTransSlider->setValue((int)m_Controls.m_XTransSlider->value() + (int)translateVec[0]);
     m_Controls.m_YTransSlider->setValue((int)m_Controls.m_YTransSlider->value() + (int)translateVec[1]);
     m_Controls.m_ZTransSlider->setValue((int)m_Controls.m_ZTransSlider->value() + (int)translateVec[2]);
   }
 }
 
 void QmitkRigidRegistrationView::SetUndoEnabled( bool enable )
 {
   m_Controls.m_UndoTransformation->setEnabled(enable);
 }
 
 void QmitkRigidRegistrationView::SetRedoEnabled( bool enable )
 {
   m_Controls.m_RedoTransformation->setEnabled(enable);
 }
 
 void QmitkRigidRegistrationView::CheckCalculateEnabled()
 {
   if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
   {
     m_Controls.m_ManualFrame->setEnabled(true);
     m_Controls.m_CalculateTransformation->setEnabled(true);
     if ( (m_FixedDimension != m_MovingDimension && std::max<int>(m_FixedDimension, m_MovingDimension) != 4) || m_FixedDimension < 2 /*|| m_FixedDimension > 3*/)
     {
       m_Controls.m_CalculateTransformation->setEnabled(false);
     }
     else if (m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() < 5 &&  (m_FixedDimension < 2) /*|| m_FixedDimension > 3)*/)
     {
       m_Controls.m_CalculateTransformation->setEnabled(false);
     }
     else if ((m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() > 4 && m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() < 13) && !(m_FixedDimension > 2))
     {
       m_Controls.m_CalculateTransformation->setEnabled(false);
     }
     else if (m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() > 12 &&  m_FixedDimension != 2)
     {
       m_Controls.m_CalculateTransformation->setEnabled(false);
     }
   }
   else
   {
     m_Controls.m_CalculateTransformation->setEnabled(false);
     m_Controls.m_ManualFrame->setEnabled(false);
   }
 }
 
 void QmitkRigidRegistrationView::xTrans_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     translationParams[0]=v;
     translationParams[1]=m_Controls.m_YTransSlider->value();
     translationParams[2]=m_Controls.m_ZTransSlider->value();
     Translate(translationParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::yTrans_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     translationParams[0]=m_Controls.m_XTransSlider->value();
     translationParams[1]=v;
     translationParams[2]=m_Controls.m_ZTransSlider->value();
     Translate(translationParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::zTrans_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     translationParams[0]=m_Controls.m_XTransSlider->value();
     translationParams[1]=m_Controls.m_YTransSlider->value();
     translationParams[2]=v;
     Translate(translationParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::xRot_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     rotationParams[0]=v;
     rotationParams[1]=m_Controls.m_YRotSlider->value();
     rotationParams[2]=m_Controls.m_ZRotSlider->value();
     Rotate(rotationParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::yRot_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     rotationParams[0]=m_Controls.m_XRotSlider->value();
     rotationParams[1]=v;
     rotationParams[2]=m_Controls.m_ZRotSlider->value();
     Rotate(rotationParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::zRot_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     rotationParams[0]=m_Controls.m_XRotSlider->value();
     rotationParams[1]=m_Controls.m_YRotSlider->value();
     rotationParams[2]=v;
     Rotate(rotationParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::xScale_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     scalingParams[0]=v;
     scalingParams[1]=m_Controls.m_YScaleSlider->value();
     scalingParams[2]=m_Controls.m_ZScaleSlider->value();
     Scale(scalingParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::yScale_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     scalingParams[0]=m_Controls.m_XScaleSlider->value();
     scalingParams[1]=v;
     scalingParams[2]=m_Controls.m_ZScaleSlider->value();
     Scale(scalingParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::zScale_valueChanged( int v )
 {
   if (m_MovingNode.IsNotNull())
   {
     scalingParams[0]=m_Controls.m_XScaleSlider->value();
     scalingParams[1]=m_Controls.m_YScaleSlider->value();
     scalingParams[2]=v;
     Scale(scalingParams);
   }
   else
   {
     MovingImageChanged();
   }
 }
 
 void QmitkRigidRegistrationView::MovingImageChanged()
 {
   if (dynamic_cast<mitk::Image*>(m_MovingNode->GetData()))
   {
     m_Controls.m_XTransSlider->setValue(0);
     m_Controls.m_YTransSlider->setValue(0);
     m_Controls.m_ZTransSlider->setValue(0);
     translationParams[0]=0;
     translationParams[1]=0;
     translationParams[2]=0;
     m_Controls.m_XRotSlider->setValue(0);
     m_Controls.m_YRotSlider->setValue(0);
     m_Controls.m_ZRotSlider->setValue(0);
     rotationParams[0]=0;
     rotationParams[1]=0;
     rotationParams[2]=0;
     m_Controls.m_XScaleSlider->setValue(0);
     m_Controls.m_YScaleSlider->setValue(0);
     m_Controls.m_ZScaleSlider->setValue(0);
     scalingParams[0]=0;
     scalingParams[1]=0;
     scalingParams[2]=0;
     m_MovingDimension = dynamic_cast<mitk::Image*>(m_MovingNode->GetData())->GetDimension();
     m_Controls.qmitkRigidRegistrationSelector1->SetMovingDimension(m_MovingDimension);
     m_Controls.qmitkRigidRegistrationSelector1->SetMovingNode(m_MovingNode);
     this->CheckCalculateEnabled();
   }
 }
 
 void QmitkRigidRegistrationView::Calculate()
 {
   m_Controls.qmitkRigidRegistrationSelector1->SetFixedNode(m_FixedNode);
   m_Controls.qmitkRigidRegistrationSelector1->SetMovingNode(m_MovingNode);
   if (m_FixedMaskNode.IsNotNull() && m_Controls.m_UseMaskingCB->isChecked())
   {
     m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(m_FixedMaskNode);
   }
   else
   {
     m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(NULL);
   }
   if (m_MovingMaskNode.IsNotNull() && m_Controls.m_UseMaskingCB->isChecked())
   {
     m_Controls.qmitkRigidRegistrationSelector1->SetMovingMaskNode(m_MovingMaskNode);
   }
   else
   {
     m_Controls.qmitkRigidRegistrationSelector1->SetMovingMaskNode(NULL);
   }
   m_Controls.frame_2->setEnabled(false);
   m_Controls.frame_3->setEnabled(false);
   m_Controls.m_CalculateTransformation->setEnabled(false);
   m_Controls.m_StopOptimization->setEnabled(true);
   m_Controls.qmitkRigidRegistrationSelector1->CalculateTransformation(((QmitkSliderNavigatorWidget*)m_Controls.timeSlider)->GetPos());
   m_Controls.m_StopOptimization->setEnabled(false);
   m_Controls.frame_2->setEnabled(true);
   m_Controls.frame_3->setEnabled(true);
   m_Controls.m_CalculateTransformation->setEnabled(true);
   m_Controls.qmitkRigidRegistrationSelector1->StopOptimization(false);
 }
 
 void QmitkRigidRegistrationView::SetOptimizerValue( double value )
 {
   m_Controls.m_OptimizerValueLCD->display(value);
 }
 
 void QmitkRigidRegistrationView::StopOptimizationClicked()
 {
   m_Controls.qmitkRigidRegistrationSelector1->StopOptimization(true);
 }
 
 void QmitkRigidRegistrationView::UpdateTimestep()
 {
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkRigidRegistrationView::ShowManualRegistrationFrame(bool show)
 {
   if (show)
   {
     m_Controls.m_ManualFrame->show();
   }
   else
   {
     m_Controls.m_ManualFrame->hide();
   }
 }
 
 void QmitkRigidRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
 {
   if (this->m_CurrentSelection->Size() == 0)
   {
     // show all images
     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
     {
-      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
+      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::PlaneGeometryData*>(nodeIt->Value()->GetData())==NULL)
       {
         nodeIt->Value()->SetVisibility(true);
       }
     }
   }
   else
   {
     // hide all images
     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
     {
-      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
+      if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::PlaneGeometryData*>(nodeIt->Value()->GetData())==NULL)
       {
         nodeIt->Value()->SetVisibility(false);
       }
     }
   }
 }
 
 void QmitkRigidRegistrationView::TabChanged(int index)
 {
   if (index == 0)
   {
     m_Controls.frame->hide();
   }
   else
   {
     m_Controls.frame->show();
   }
 }
 
 void QmitkRigidRegistrationView::SwitchImages()
 {
   mitk::DataNode::Pointer newMoving = m_FixedNode;
   mitk::DataNode::Pointer newFixed = m_MovingNode;
   this->FixedSelected(newFixed);
   this->MovingSelected(newMoving);
 
   if(m_ContourHelperNode.IsNotNull())
   {
     // Update the contour
     ShowContour();
   }
 
   if(m_Controls.m_UseMaskingCB->isChecked())
   {
     mitk::DataNode::Pointer tempMovingMask = NULL;
     mitk::DataNode::Pointer tempFixedMask = NULL;
 
     if(m_FixedMaskNode.IsNotNull()) // it is initialized
     {
       tempFixedMask = m_Controls.m_FixedImageCB->GetSelectedNode();
     }
 
     if(m_MovingMaskNode.IsNotNull())  // it is initialized
     {
       tempMovingMask = m_Controls.m_MovingImageCB->GetSelectedNode();
     }
     m_Controls.m_FixedImageCB->SetSelectedNode(tempMovingMask);
     m_Controls.m_MovingImageCB->SetSelectedNode(tempFixedMask);
   }
 }
 
 void QmitkRigidRegistrationView::OnUseMaskingChanged( int state )
 {
   if(state == Qt::Checked)
   {
     m_Controls.m_FixedImageCB->show();
     m_Controls.m_MovingImageCB->show();
     m_Controls.m_MovingMaskLB->show();
     m_Controls.m_FixedMaskLB->show();
   }
   else
   {
     m_Controls.m_FixedImageCB->hide();
     m_Controls.m_MovingImageCB->hide();
     m_Controls.m_MovingMaskLB->hide();
     m_Controls.m_FixedMaskLB->hide();
 
     m_FixedMaskNode = NULL;
     m_MovingMaskNode = NULL;
   }
 }
 
 void QmitkRigidRegistrationView::OnFixedMaskImageChanged( const mitk::DataNode* node )
 {
   if(m_Controls.m_UseMaskingCB->isChecked())
     m_FixedMaskNode = const_cast<mitk::DataNode*>(node);
   else
     m_FixedMaskNode = NULL;
 }
 
 void QmitkRigidRegistrationView::OnMovingMaskImageChanged( const mitk::DataNode* node )
 {
   if(m_Controls.m_UseMaskingCB->isChecked())
     m_MovingMaskNode = const_cast<mitk::DataNode*>(node);
   else
     m_MovingMaskNode = NULL;
 }
\ No newline at end of file