diff --git a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
index 19ce4201ea..aeb92fcffb 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 TimeSlicedGeometry *inputTimeGeometry = this->GetInput()->GetTimeSlicedGeometry();
+  const TimeGeometry* inputTimeGeometry = this->GetInput()->GetTimeGeometry();
   if ( ( inputTimeGeometry == NULL )
-    || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
+    || ( inputTimeGeometry->GetNumberOfTimeSteps() <= 0 ) )
   {
-    itkWarningMacro(<<"Error reading input image TimeSlicedGeometry.");
+    itkWarningMacro(<<"Error reading input image TimeGeometry.");
     return;
   }
 
   // is it a valid timeStep?
-  if ( inputTimeGeometry->IsValidTime( m_TimeStep ) == false )
+  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->GetGeometry3D( m_TimeStep )->WorldToIndex( right, rightInIndex );
-      inputTimeGeometry->GetGeometry3D( m_TimeStep )->WorldToIndex( bottom, 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),
     // 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->GetGeometry3D( m_TimeStep )->GetVtkTransform()->GetLinearInverse() );
+        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)
       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->SetInput( input->GetVtkImageData(m_TimeStep) );
 
     m_Reslicer->SetInput(unitSpacingImageFilter->GetOutput() );
   }
   else
   {
     //if no tranform is set the image can be used directly
     m_Reslicer->SetInput(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]);
 
   vtkFloatingPointType 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();
 //    Geometry2D::Pointer originalGeometry = dynamic_cast<Geometry2D*>( originalGeometryAGF.GetPointer() );
     Geometry2D::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(vtkFloatingPointType 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 Geometry3D *boundingGeometry,
                                                      const PlaneGeometry *planeGeometry, vtkFloatingPointType *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 57b6d1813e..46444a34bb 100644
--- a/Core/Code/Algorithms/mitkExtractSliceFilter.h
+++ b/Core/Code/Algorithms/mitkExtractSliceFilter.h
@@ -1,174 +1,174 @@
 /*===================================================================
 
 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 "MitkExports.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
   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 timesliced volume.
+  - 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);
     itkNewMacro(ExtractSliceFilter);
 
     mitkNewMacro1Param(Self, vtkImageReslice*);
 
     /** \brief Set the axis where to reslice at.*/
     void SetWorldGeometry(const Geometry2D* 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 Geometry3D* 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*, vtkFloatingPointType*)
     * 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 Geometry3D *boundingGeometry,
       const PlaneGeometry *planeGeometry, vtkFloatingPointType *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 Geometry2D* 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;
 
     Geometry3D::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/mitkGeometry2DDataToSurfaceFilter.cpp b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
index 6337f1613a..4bbdbf2ddb 100644
--- a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
+++ b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
@@ -1,449 +1,445 @@
 /*===================================================================
 
 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 "mitkSurface.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometry2DData.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()
 : 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->SetInput( m_PlaneSource->GetOutput() );
 }
 
 
 mitk::Geometry2DDataToSurfaceFilter::~Geometry2DDataToSurfaceFilter()
 {
   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()
 {
   mitk::Geometry2DData::ConstPointer input = this->GetInput();
   mitk::Surface::Pointer output = this->GetOutput();
 
   if ( input.IsNull() || (input->GetGeometry2D() == NULL)
     || (input->GetGeometry2D()->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 )
   {
     mitk::PlaneGeometry *planeGeometry =
       dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() );
 
     if ( m_PlaceByGeometry )
     {
       // Let the output use the input geometry to appropriately transform the
       // coordinate system.
-      mitk::AffineGeometryFrame3D::TransformType *affineTransform =
+      mitk::Geometry3D::TransformType *affineTransform =
         planeGeometry->GetIndexToWorldTransform();
 
-      mitk::TimeSlicedGeometry *timeGeometry = output->GetTimeSlicedGeometry();
-      timeGeometry->SetIndexToWorldTransform( affineTransform );
-
-      mitk::Geometry3D *g3d = timeGeometry->GetGeometry3D( 0 );
-      g3d->SetIndexToWorldTransform( affineTransform );
+      TimeGeometry *timeGeometry = output->GetTimeGeometry();
+      Geometry3D *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] );
 
       planeSurface = m_PlaneSource->GetOutput();
       planeSurface->Update();
     }
     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()
       );
 
       Geometry3D *referenceGeometry = planeGeometry->GetReferenceGeometry();
       if ( referenceGeometry )
       {
         m_Transform->Concatenate(
           referenceGeometry->GetVtkTransform()
         );
       }
 
       // Transform the cube accordingly (s.a.)
       m_PolyDataTransformer->SetInput( m_CubeSource->GetOutput() );
       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->SetInput( m_PolyDataTransformer->GetOutput() );
       m_PlaneCutter->SetCutFunction( m_Plane );
 
       // The output of the cutter must be converted into appropriate poly data.
       m_PlaneStripper->SetInput( m_PlaneCutter->GetOutput() );
       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->SetInput( m_PlanePolyData );
 
 
       // Get bounds of the resulting surface and use it to generate the texture
       // mapping information
       m_PlaneTriangler->Update();
       m_PlaneTriangler->GetOutput()->ComputeBounds();
       vtkFloatingPointType *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->SetInput( m_PlaneTriangler->GetOutput() );
       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?
   else if ( mitk::AbstractTransformGeometry *abstractGeometry =
     dynamic_cast< AbstractTransformGeometry * >( input->GetGeometry2D() ) )
   {
     // 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::AffineGeometryFrame3D::TransformType *affineTransform =
+      mitk::Geometry3D::TransformType *affineTransform =
         abstractGeometry->GetIndexToWorldTransform();
 
-      mitk::TimeSlicedGeometry *timeGeometry = output->GetTimeSlicedGeometry();
-      timeGeometry->SetIndexToWorldTransform( affineTransform );
-
-      mitk::Geometry3D *g3d = timeGeometry->GetGeometry3D( 0 );
+      TimeGeometry *timeGeometry = output->GetTimeGeometry();
+      Geometry3D *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->PreMultiply();
 
     m_Box->SetTransform( m_Transform );
 
     m_PlaneClipper->SetInput( m_VtkTransformPlaneFilter->GetOutput() );
     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 );
 
     planeSurface = m_PlaneClipper->GetOutput();
   }
 
   m_NormalsUpdater->SetInput( 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()
 {
   mitk::Surface::Pointer output = this->GetOutput();
 
   if (output.IsNull()) return;
   if (output->GetVtkPolyData()==NULL) return;
 
   output->GetVtkPolyData()->Update();
 }
 
 const mitk::Geometry2DData *mitk::Geometry2DDataToSurfaceFilter::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Geometry2DData * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 
 const mitk::Geometry2DData *
 mitk::Geometry2DDataToSurfaceFilter
 ::GetInput(unsigned int idx)
 {
   return static_cast< const mitk::Geometry2DData * >
     ( this->ProcessObject::GetInput(idx) );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetInput(const mitk::Geometry2DData *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 0,
   const_cast< mitk::Geometry2DData * >( input )
   );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetInput(unsigned int index, const mitk::Geometry2DData *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 )
   );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetBoundingBox( const mitk::BoundingBox *boundingBox )
 {
   m_BoundingBox = boundingBox;
   this->UseBoundingBoxOn();
 }
 
 
 const mitk::BoundingBox *
 mitk::Geometry2DDataToSurfaceFilter
 ::GetBoundingBox() const
 {
   return m_BoundingBox.GetPointer();
 }
diff --git a/Core/Code/Algorithms/mitkImageChannelSelector.cpp b/Core/Code/Algorithms/mitkImageChannelSelector.cpp
index bc8c79ca06..5d2bdfa865 100644
--- a/Core/Code/Algorithms/mitkImageChannelSelector.cpp
+++ b/Core/Code/Algorithms/mitkImageChannelSelector.cpp
@@ -1,75 +1,76 @@
 /*===================================================================
 
 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 "mitkImageChannelSelector.h"
 
 
 mitk::ImageChannelSelector::ImageChannelSelector() : m_ChannelNr(0)
 {
 }
 
 mitk::ImageChannelSelector::~ImageChannelSelector()
 {
 }
 
 void mitk::ImageChannelSelector::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input  = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   output->Initialize(input->GetPixelType(), input->GetDimension(), input->GetDimensions());
 
   // initialize geometry
   output->SetPropertyList(input->GetPropertyList()->Clone());
-  output->SetGeometry(dynamic_cast<Geometry3D*>(input->GetTimeSlicedGeometry()->Clone().GetPointer()));
+  itk::LightObject::Pointer clonGeometry = input->GetTimeGeometry()->Clone();
+  output->SetTimeGeometry(dynamic_cast<TimeGeometry *>(clonGeometry.GetPointer()));
 }
 
 void mitk::ImageChannelSelector::GenerateData()
 {
   const Image::RegionType& requestedRegion = GetOutput()->GetRequestedRegion();
 
   //do we really need the complete channel?
   if(requestedRegion.GetSize(3)>1)
     SetChannelItem(GetChannelData(m_ChannelNr), 0);
   else
   //or only a complete volume at a time?
   if(requestedRegion.GetSize(2)>1)
     SetVolumeItem(GetVolumeData(requestedRegion.GetIndex(3), m_ChannelNr), requestedRegion.GetIndex(3), 0);
   else
   //not even a complete volume, so now take just a slice!
     SetSliceItem(GetSliceData(requestedRegion.GetIndex(2), requestedRegion.GetIndex(3), m_ChannelNr), requestedRegion.GetIndex(2), requestedRegion.GetIndex(3), 0);
 }
 
 void mitk::ImageChannelSelector::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(4, m_ChannelNr);
   requestedRegion.SetSize(4, 1);
 
   input->SetRequestedRegion( & requestedRegion );
 }
 
 
diff --git a/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp b/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp
index eebd163c28..f76fb6bcfc 100644
--- a/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp
+++ b/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp
@@ -1,232 +1,231 @@
 /*===================================================================
 
 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 "mitkRGBToRGBACastImageFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageToItk.h"
 
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkImageIOBase.h>
 #include <itkRGBAPixel.h>
 
 
 mitk::RGBToRGBACastImageFilter::RGBToRGBACastImageFilter()
 {
   this->SetNumberOfIndexedInputs(1);
   this->SetNumberOfRequiredInputs(1);
 
   m_InputTimeSelector  = mitk::ImageTimeSelector::New();
   m_OutputTimeSelector = mitk::ImageTimeSelector::New();
 }
 
 
 mitk::RGBToRGBACastImageFilter::~RGBToRGBACastImageFilter()
 {
 }
 
 
 bool mitk::RGBToRGBACastImageFilter::IsRGBImage( const mitk::Image *image )
 {
   const mitk::PixelType &inputPixelType = image->GetPixelType();
 
   if ( (inputPixelType.GetPixelType() == itk::ImageIOBase::RGB )
     && ( (inputPixelType.GetComponentType() == itk::ImageIOBase::UCHAR )
       || (inputPixelType.GetComponentType() == itk::ImageIOBase::USHORT )
       || (inputPixelType.GetComponentType() == itk::ImageIOBase::FLOAT )
       || (inputPixelType.GetComponentType() == itk::ImageIOBase::DOUBLE )
        )
      )
   {
     return true;
   }
 
   return false;
 }
 
 
 void mitk::RGBToRGBACastImageFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::Image* output = this->GetOutput();
   mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
   if ( !output->IsInitialized() )
   {
     return;
   }
 
   input->SetRequestedRegionToLargestPossibleRegion();
 
   //GenerateTimeInInputRegion(output, input);
 }
 
 void mitk::RGBToRGBACastImageFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   // Initialize RGBA output with same pixel type as input image
   const mitk::PixelType &inputPixelType = input->GetPixelType();
 
   typedef itk::Image< UCRGBPixelType > UCRGBItkImageType;
   typedef itk::Image< USRGBPixelType > USRGBItkImageType;
   typedef itk::Image< FloatRGBPixelType > FloatCRGBItkImageType;
   typedef itk::Image< DoubleRGBPixelType > DoubleRGBItkImageType;
 
   if ( inputPixelType == mitk::MakePixelType< UCRGBItkImageType>() )
   {
     const mitk::PixelType refPtype = MakePixelType<UCRGBItkImageType>();
-    output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
+    output->Initialize( refPtype, *input->GetTimeGeometry() );
 
   }
   else if ( inputPixelType == mitk::MakePixelType< USRGBItkImageType>( ) )
   {
     const mitk::PixelType refPtype = MakePixelType<USRGBItkImageType>();
-    output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
+    output->Initialize( refPtype, *input->GetTimeGeometry() );
   }
   else if ( inputPixelType == mitk::MakePixelType< FloatCRGBItkImageType>( ) )
   {
     const mitk::PixelType refPtype = MakePixelType<FloatCRGBItkImageType>();
-    output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
+    output->Initialize( refPtype, *input->GetTimeGeometry() );
   }
   else if ( inputPixelType == mitk::MakePixelType< DoubleRGBItkImageType>( ) )
   {
     const mitk::PixelType refPtype = MakePixelType<DoubleRGBItkImageType>();
-    output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
+    output->Initialize( refPtype, *input->GetTimeGeometry() );
   }
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 
 void mitk::RGBToRGBACastImageFilter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if( !output->IsInitialized() )
   {
     return;
   }
 
   m_InputTimeSelector->SetInput(input);
   m_OutputTimeSelector->SetInput(this->GetOutput());
 
   mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
-  const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
-  ScalarType timeInMS;
+  const mitk::TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
+  const mitk::TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
+  TimePointType 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->TimeStepToMS( t );
-
-    timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
+    timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
+    timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
 
     m_InputTimeSelector->SetTimeNr(timestep);
     m_InputTimeSelector->UpdateLargestPossibleRegion();
     m_OutputTimeSelector->SetTimeNr(t);
     m_OutputTimeSelector->UpdateLargestPossibleRegion();
 
     mitk::Image *image = m_InputTimeSelector->GetOutput();
 
     const mitk::PixelType &pixelType = image->GetPixelType();
 
     // Check if the pixel type is supported
     if ( pixelType == MakePixelType< itk::Image<UCRGBPixelType> >() )
     {
       AccessFixedPixelTypeByItk_2( image, InternalCast, (UCRGBPixelType), this, 255 );
     }
     else if ( pixelType == MakePixelType< itk::Image< USRGBPixelType> >() )
     {
       AccessFixedPixelTypeByItk_2( image, InternalCast, (USRGBPixelType), this, 65535 );
     }
     else if ( pixelType == MakePixelType< itk::Image< FloatRGBPixelType> >() )
     {
       AccessFixedPixelTypeByItk_2( image, InternalCast, (FloatRGBPixelType), this, 1.0 );
     }
     else if ( pixelType == MakePixelType< itk::Image< DoubleRGBPixelType> >() )
     {
       AccessFixedPixelTypeByItk_2( image, InternalCast, (DoubleRGBPixelType), this, 1.0 );
     }
     else
     {
       // Otherwise, write warning and graft input to output
 
       // ...TBD...
     }
 
   }
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void mitk::RGBToRGBACastImageFilter::InternalCast(
   itk::Image< TPixel, VImageDimension > *inputItkImage,
   mitk::RGBToRGBACastImageFilter *addComponentFilter,
   typename TPixel::ComponentType defaultAlpha )
 {
   typedef TPixel InputPixelType;
   typedef itk::RGBAPixel< typename TPixel::ComponentType > OutputPixelType;
   typedef itk::Image< InputPixelType, VImageDimension > InputImageType;
   typedef itk::Image< OutputPixelType, VImageDimension > OutputImageType;
 
   typedef itk::ImageRegionConstIterator< InputImageType > InputImageIteratorType;
   typedef itk::ImageRegionIteratorWithIndex< OutputImageType > OutputImageIteratorType;
 
   typename mitk::ImageToItk< OutputImageType >::Pointer outputimagetoitk =
     mitk::ImageToItk< OutputImageType >::New();
   outputimagetoitk->SetInput(addComponentFilter->m_OutputTimeSelector->GetOutput());
   outputimagetoitk->Update();
   typename OutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
 
   // create the iterators
   typename InputImageType::RegionType inputRegionOfInterest =
     inputItkImage->GetLargestPossibleRegion();
   InputImageIteratorType  inputIt( inputItkImage, inputRegionOfInterest );
   OutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
 
   for ( inputIt.GoToBegin(), outputIt.GoToBegin();
         !inputIt.IsAtEnd();
         ++inputIt, ++outputIt )
   {
     typename InputPixelType::Iterator pixelInputIt = inputIt.Get().Begin();
     typename OutputPixelType::Iterator pixelOutputIt = outputIt.Get().Begin();
 
     *pixelOutputIt++ = *pixelInputIt++;
     *pixelOutputIt++ = *pixelInputIt++;
     *pixelOutputIt++ = *pixelInputIt++;
     *pixelOutputIt = defaultAlpha;
   }
 }
diff --git a/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp b/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp
index f2acb4afd0..c7680fea20 100644
--- a/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp
+++ b/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp
@@ -1,211 +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 "mitkSurfaceToImageFilter.h"
 #include "mitkTimeHelper.h"
 #include "mitkImageWriteAccessor.h"
 
 #include <vtkPolyData.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkImageStencil.h>
 #include <vtkImageData.h>
 #include <vtkPolyData.h>
 #include <vtkLinearTransform.h>
 #include <vtkTriangleFilter.h>
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkDataSetTriangleFilter.h>
 #include <vtkImageThreshold.h>
 #include <vtkImageMathematics.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTransform.h>
 
 
 mitk::SurfaceToImageFilter::SurfaceToImageFilter()
 : m_MakeOutputBinary( false ),
   m_BackgroundValue( -10000 )
 {
 }
 
 mitk::SurfaceToImageFilter::~SurfaceToImageFilter()
 {
 }
 
 void mitk::SurfaceToImageFilter::GenerateInputRequestedRegion()
 {
   mitk::Image* output = this->GetOutput();
   if((output->IsInitialized()==false) )
     return;
 
   GenerateTimeInInputRegion(output, const_cast< mitk::Image * > ( this->GetImage() ));
 }
 
 void mitk::SurfaceToImageFilter::GenerateOutputInformation()
 {
   mitk::Image *inputImage = (mitk::Image*)this->GetImage();
   mitk::Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   if((inputImage == NULL) ||
      (inputImage->IsInitialized() == false) ||
-     (inputImage->GetTimeSlicedGeometry() == NULL)) return;
+     (inputImage->GetTimeGeometry() == NULL)) return;
 
   if (m_MakeOutputBinary)
-    output->Initialize(mitk::MakeScalarPixelType<unsigned char>() , *inputImage->GetTimeSlicedGeometry());
+    output->Initialize(mitk::MakeScalarPixelType<unsigned char>() , *inputImage->GetTimeGeometry());
   else
-    output->Initialize(inputImage->GetPixelType(), *inputImage->GetTimeSlicedGeometry());
+    output->Initialize(inputImage->GetPixelType(), *inputImage->GetTimeGeometry());
 
   output->SetPropertyList(inputImage->GetPropertyList()->Clone());
 }
 
 void mitk::SurfaceToImageFilter::GenerateData()
 {
   mitk::Image::ConstPointer inputImage = this->GetImage();
   mitk::Image::Pointer output = this->GetOutput();
 
   if(inputImage.IsNull())
     return;
 
   if(output->IsInitialized()==false )
     return;
 
   mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
 
   int tstart=outputRegion.GetIndex(3);
   int tmax=tstart+outputRegion.GetSize(3);
 
   if ( tmax > 0)
   {
     int t;
     for(t=tstart;t<tmax;++t)
     {
       Stencil3DImage( t );
     }
   }
   else
   {
     Stencil3DImage( 0 );
   }
 }
 
 void mitk::SurfaceToImageFilter::Stencil3DImage(int time)
 {
-  const mitk::TimeSlicedGeometry *surfaceTimeGeometry = GetInput()->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *imageTimeGeometry = GetImage()->GetTimeSlicedGeometry();
+  const mitk::TimeGeometry *surfaceTimeGeometry = GetInput()->GetTimeGeometry();
+  const mitk::TimeGeometry *imageTimeGeometry = GetImage()->GetTimeGeometry();
 
   // Convert time step from image time-frame to surface time-frame
-  int surfaceTimeStep = surfaceTimeGeometry->TimeStepToTimeStep( imageTimeGeometry, time );
+  mitk::TimePointType matchingTimePoint = imageTimeGeometry->TimeStepToTimePoint(time);
+  mitk::TimeStepType surfaceTimeStep = surfaceTimeGeometry->TimePointToTimeStep(matchingTimePoint);
 
   vtkPolyData * polydata = ( (mitk::Surface*)GetInput() )->GetVtkPolyData( surfaceTimeStep );
 
   vtkTransformPolyDataFilter * move=vtkTransformPolyDataFilter::New();
   move->SetInput(polydata);
   move->ReleaseDataFlagOn();
 
   vtkTransform *transform=vtkTransform::New();
-  Geometry3D* geometry = surfaceTimeGeometry->GetGeometry3D( surfaceTimeStep );
+  Geometry3D* geometry = surfaceTimeGeometry->GetGeometryForTimeStep( surfaceTimeStep );
   geometry->TransferItkToVtkTransform();
   transform->PostMultiply();
   transform->Concatenate(geometry->GetVtkTransform()->GetMatrix());
   // take image geometry into account. vtk-Image information will be changed to unit spacing and zero origin below.
-  Geometry3D* imageGeometry = imageTimeGeometry->GetGeometry3D(time);
+  Geometry3D* imageGeometry = imageTimeGeometry->GetGeometryForTimeStep(time);
   imageGeometry->TransferItkToVtkTransform();
   transform->Concatenate(imageGeometry->GetVtkTransform()->GetLinearInverse());
   move->SetTransform(transform);
   transform->Delete();
 
   vtkPolyDataNormals * normalsFilter = vtkPolyDataNormals::New();
   normalsFilter->SetFeatureAngle(50);
   normalsFilter->SetConsistency(1);
   normalsFilter->SetSplitting(1);
   normalsFilter->SetFlipNormals(0);
   normalsFilter->ReleaseDataFlagOn();
 
   normalsFilter->SetInput( move->GetOutput() );
   move->Delete();
 
   vtkPolyDataToImageStencil * surfaceConverter = vtkPolyDataToImageStencil::New();
   surfaceConverter->SetTolerance( 0.0 );
   surfaceConverter->ReleaseDataFlagOn();
 
   surfaceConverter->SetInput( normalsFilter->GetOutput() );
   normalsFilter->Delete();
 
   mitk::Image::Pointer binaryImage = mitk::Image::New();
 
   if (m_MakeOutputBinary)
   {
-    binaryImage->Initialize(mitk::MakeScalarPixelType<unsigned char>(), *this->GetImage()->GetTimeSlicedGeometry());
+    binaryImage->Initialize(mitk::MakeScalarPixelType<unsigned char>(), *this->GetImage()->GetTimeGeometry());
 
     unsigned int size = sizeof(unsigned char);
     for (unsigned int i = 0; i < binaryImage->GetDimension(); ++i)
       size *= binaryImage->GetDimension(i);
 
     mitk::ImageWriteAccessor accessor( binaryImage );
     memset( accessor.GetData(), 1, size );
   }
 
   vtkImageData *image = m_MakeOutputBinary
     ? binaryImage->GetVtkImageData(time)
     : const_cast<mitk::Image *>(this->GetImage())->GetVtkImageData(time);
 
   // Create stencil and use numerical minimum of pixel type as background value
   vtkImageStencil *stencil = vtkImageStencil::New();
   stencil->SetInput(image);
   stencil->ReverseStencilOff();
   stencil->ReleaseDataFlagOn();
   stencil->SetStencil(surfaceConverter->GetOutput());
   surfaceConverter->Delete();
 
   stencil->SetBackgroundValue(m_MakeOutputBinary ? 0 : m_BackgroundValue);
   stencil->Update();
 
   mitk::Image::Pointer output = this->GetOutput();
   output->SetVolume( stencil->GetOutput()->GetScalarPointer(), time );
   MITK_INFO << "stencil ref count: " << stencil->GetReferenceCount() << std::endl;
 
   stencil->Delete();
 }
 
 
 const mitk::Surface *mitk::SurfaceToImageFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Surface * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 void mitk::SurfaceToImageFilter::SetInput(const mitk::Surface *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0,
     const_cast< mitk::Surface * >( input ) );
 }
 
 void mitk::SurfaceToImageFilter::SetImage(const mitk::Image *source)
 {
   this->ProcessObject::SetNthInput( 1, const_cast< mitk::Image * >( source ) );
 }
 
 const mitk::Image *mitk::SurfaceToImageFilter::GetImage(void)
 {
   return static_cast< const mitk::Image * >(this->ProcessObject::GetInput(1));
-}
+}
\ No newline at end of file
diff --git a/Core/Code/Algorithms/mitkTimeHelper.h b/Core/Code/Algorithms/mitkTimeHelper.h
index 3ae3bab7bf..ad644043eb 100644
--- a/Core/Code/Algorithms/mitkTimeHelper.h
+++ b/Core/Code/Algorithms/mitkTimeHelper.h
@@ -1,76 +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 MITKTIMEHELPER_H_HEADER_INCLUDED_C1C2FCD2
 #define MITKTIMEHELPER_H_HEADER_INCLUDED_C1C2FCD2
 
+#include <mitkTimeGeometry.h>
+
 namespace mitk
 {
 
 //## @brief convert the start- and end-index-time of output-region in
 //## start- and end-index-time of input-region via millisecond-time
 template <class TOutputRegion, class TInputRegion>
-void GenerateTimeInInputRegion(const mitk::TimeSlicedGeometry *outputTimeGeometry, const TOutputRegion& outputRegion, const mitk::TimeSlicedGeometry *inputTimeGeometry, TInputRegion& inputRegion)
+void GenerateTimeInInputRegion(const mitk::TimeGeometry *outputTimeGeometry, const TOutputRegion& outputRegion, const mitk::TimeGeometry *inputTimeGeometry, TInputRegion& inputRegion)
 {
   assert(outputTimeGeometry!=NULL);
   assert(inputTimeGeometry!=NULL);
 
   // convert the start-index-time of output in start-index-time of input via millisecond-time
-  ScalarType timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3));
-  int timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
-  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( inputTimeGeometry->IsValidTime( timestep ) ) )
+  mitk::TimePointType timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3));
+  mitk::TimeStepType timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
+  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( inputTimeGeometry->IsValidTimeStep( timestep ) ) )
     inputRegion.SetIndex( 3, timestep );
   else
     inputRegion.SetIndex( 3, 0 );
   // convert the end-index-time of output in end-index-time of input via millisecond-time
-  timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
-  timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
-  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTime( timestep ) ) )
+  timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
+  timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
+  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTimeStep( timestep ) ) )
     inputRegion.SetSize( 3, timestep - inputRegion.GetIndex(3) + 1 );
   else
     inputRegion.SetSize( 3, 1 );
 }
 
 //##Documentation
 //## @brief convert the start- and end-index-time of output in
 //## start- and end-index-time of input1 and input2 via millisecond-time
 template <class TOutputData, class TInputData>
 void GenerateTimeInInputRegion(const TOutputData* output, TInputData* input)
 {
   assert(output!=NULL);
   assert(input!=NULL);
 
   const typename TOutputData::RegionType& outputRegion = output->GetRequestedRegion();
   typename TInputData::RegionType inputRegion;
 
   if(outputRegion.GetSize(3)<1)
   {
     typename TInputData::RegionType::SizeType inputsize;
     inputsize.Fill(0);
     inputRegion.SetSize(inputsize);
     input->SetRequestedRegion( &inputRegion );
   }
 
   // convert the start-index-time of output in start-index-time of input via millisecond-time
   inputRegion = input->GetRequestedRegion();
-  GenerateTimeInInputRegion(output->GetTimeSlicedGeometry(), outputRegion, input->GetTimeSlicedGeometry(), inputRegion);
+  GenerateTimeInInputRegion(output->GetTimeGeometry(), outputRegion, input->GetTimeGeometry(), inputRegion);
   input->SetRequestedRegion( &inputRegion  );
 }
 
 } // end namespace mitk
 
 #endif // MITKTIMEHELPER_H_HEADER_INCLUDED_C1C2FCD2
diff --git a/Core/Code/Common/mitkCoreObjectFactory.cpp b/Core/Code/Common/mitkCoreObjectFactory.cpp
index a909c77dfa..dc887c4b49 100644
--- a/Core/Code/Common/mitkCoreObjectFactory.cpp
+++ b/Core/Code/Common/mitkCoreObjectFactory.cpp
@@ -1,405 +1,405 @@
 /*===================================================================
 
 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 "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 "mitkPolyDataGLMapper2D.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 "mitkTimeSlicedGeometry.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"
 
 mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::m_FileWriters;
 
 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()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "CoreObjectFactory c'tor" << std::endl;
 
     // FIXME itk::ObjectFactoryBase::RegisterFactory( PicFileIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( PointSetIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( STLFileIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( VtkSurfaceIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( VtkImageIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( VtiFileIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( ItkImageFileIOFactory::New() );
     // FIXME itk::ObjectFactoryBase::RegisterFactory( PicVolumeTimeSeriesIOFactory::New() );
 
     mitk::SurfaceVtkWriterFactory::RegisterOneFactory();
     mitk::PointSetWriterFactory::RegisterOneFactory();
     mitk::ImageWriterFactory::RegisterOneFactory();
     m_FileWriters.push_back(mitk::ImageWriter::New().GetPointer());
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 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))
       {
         newMapper = mitk::Geometry2DDataMapper2D::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))
       {
         newMapper = mitk::Geometry2DDataVtkMapper3D::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_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>("*.nii", "NIfTI 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;
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
     FileWriterList list2 = (*it)->GetFileWriters();
     allWriters.merge(list2);
   }
   return allWriters;
 }
 void mitk::CoreObjectFactory::MapEvent(const mitk::Event*, const int) {
 
 }
 
diff --git a/Core/Code/Controllers/mitkRenderingManager.cpp b/Core/Code/Controllers/mitkRenderingManager.cpp
index 8c39fa5615..a41a29f6f5 100644
--- a/Core/Code/Controllers/mitkRenderingManager.cpp
+++ b/Core/Code/Controllers/mitkRenderingManager.cpp
@@ -1,1031 +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 "mitkRenderingManager.h"
 #include "mitkRenderingManagerFactory.h"
 #include "mitkBaseRenderer.h"
 #include "mitkGlobalInteraction.h"
 
 #include <vtkRenderWindow.h>
 
 #include <itkCommand.h>
 #include "mitkVector.h"
 #include <itkAffineGeometryFrame.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkVtkPropRenderer.h>
 
 #include <algorithm>
 
 namespace mitk
 {
 
 RenderingManager::Pointer RenderingManager::s_Instance = 0;
 RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = 0;
 
 
 RenderingManager
 ::RenderingManager()
 : m_UpdatePending( false ),
   m_MaxLOD( 1 ),
   m_LODIncreaseBlocked( false ),
   m_LODAbortMechanismEnabled( false ),
   m_ClippingPlaneEnabled( false ),
   m_TimeNavigationController( SliceNavigationController::New("dummy") ),
   m_DataStorage( NULL ),
   m_ConstrainedPaddingZooming ( true )
 {
   m_ShadingEnabled.assign( 3, false );
   m_ShadingValues.assign( 4, 0.0 );
 
   m_GlobalInteraction = mitk::GlobalInteraction::GetInstance();
 
   InitializePropertyList();
 }
 
 
 RenderingManager
 ::~RenderingManager()
 {
   // Decrease reference counts of all registered vtkRenderWindows for
   // proper destruction
   RenderWindowVector::iterator it;
   for ( it = m_AllRenderWindows.begin(); it != m_AllRenderWindows.end(); ++it )
   {
     (*it)->UnRegister( NULL );
 
     RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(*it);
 
     if (callbacks_it != this->m_RenderWindowCallbacksList.end())
     {
       (*it)->RemoveObserver(callbacks_it->second.commands[0u]);
       (*it)->RemoveObserver(callbacks_it->second.commands[1u]);
       (*it)->RemoveObserver(callbacks_it->second.commands[2u]);
     }
   }
 }
 
 
 void
 RenderingManager
 ::SetFactory( RenderingManagerFactory *factory )
 {
   s_RenderingManagerFactory = factory;
 }
 
 
 const RenderingManagerFactory *
 RenderingManager
 ::GetFactory()
 {
   return s_RenderingManagerFactory;
 }
 
 
 bool
 RenderingManager
 ::HasFactory()
 {
   if ( RenderingManager::s_RenderingManagerFactory )
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 RenderingManager::Pointer
 RenderingManager
 ::New()
 {
   const RenderingManagerFactory* factory = GetFactory();
   if(factory == NULL)
     return NULL;
   return factory->CreateRenderingManager();
 }
 
 RenderingManager *
 RenderingManager
 ::GetInstance()
 {
   if ( !RenderingManager::s_Instance )
   {
     if ( s_RenderingManagerFactory )
     {
       s_Instance = s_RenderingManagerFactory->CreateRenderingManager();
     }
   }
 
   return s_Instance;
 }
 
 
 bool
 RenderingManager
 ::IsInstantiated()
 {
   if ( RenderingManager::s_Instance )
     return true;
   else
     return false;
 }
 
 
 void
 RenderingManager
 ::AddRenderWindow( vtkRenderWindow *renderWindow )
 {
   if ( renderWindow
     && (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end()) )
   {
     m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
     m_AllRenderWindows.push_back( renderWindow );
 
     if ( m_DataStorage.IsNotNull() )
       mitk::BaseRenderer::GetInstance( renderWindow )->SetDataStorage( m_DataStorage.GetPointer() );
 
 
     // Register vtkRenderWindow instance
     renderWindow->Register( NULL );
 
     // Add callbacks for rendering abort mechanism
     //BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
     vtkCallbackCommand *startCallbackCommand = vtkCallbackCommand::New();
     startCallbackCommand->SetCallback(
       RenderingManager::RenderingStartCallback );
     renderWindow->AddObserver( vtkCommand::StartEvent, startCallbackCommand );
 
     vtkCallbackCommand *progressCallbackCommand = vtkCallbackCommand::New();
     progressCallbackCommand->SetCallback(
       RenderingManager::RenderingProgressCallback );
     renderWindow->AddObserver( vtkCommand::AbortCheckEvent, progressCallbackCommand );
 
     vtkCallbackCommand *endCallbackCommand = vtkCallbackCommand::New();
     endCallbackCommand->SetCallback(
       RenderingManager::RenderingEndCallback );
     renderWindow->AddObserver( vtkCommand::EndEvent, endCallbackCommand );
 
     RenderWindowCallbacks callbacks;
 
     callbacks.commands[0u] = startCallbackCommand;
     callbacks.commands[1u] = progressCallbackCommand;
     callbacks.commands[2u] = endCallbackCommand;
     this->m_RenderWindowCallbacksList[renderWindow] = callbacks;
 
     //Delete vtk variables correctly
     startCallbackCommand->Delete();
     progressCallbackCommand->Delete();
     endCallbackCommand->Delete();
 
   }
 }
 
 
 void
 RenderingManager
 ::RemoveRenderWindow( vtkRenderWindow *renderWindow )
 {
   if (m_RenderWindowList.erase( renderWindow ))
   {
     RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(renderWindow);
     if(callbacks_it != this->m_RenderWindowCallbacksList.end())
     {
       renderWindow->RemoveObserver(callbacks_it->second.commands[0u]);
       renderWindow->RemoveObserver(callbacks_it->second.commands[1u]);
       renderWindow->RemoveObserver(callbacks_it->second.commands[2u]);
       this->m_RenderWindowCallbacksList.erase(callbacks_it);
     }
 
     RenderWindowVector::iterator rw_it = std::find( m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow );
 
     if(rw_it != m_AllRenderWindows.end())
     {
       // Decrease reference count for proper destruction
       (*rw_it)->UnRegister(NULL);
       m_AllRenderWindows.erase( rw_it );
     }
   }
 }
 
 
 const RenderingManager::RenderWindowVector&
 RenderingManager
 ::GetAllRegisteredRenderWindows()
 {
   return m_AllRenderWindows;
 }
 
 
 void
 RenderingManager
 ::RequestUpdate( vtkRenderWindow *renderWindow )
 {
 
   // If the renderWindow is not valid, we do not want to inadvertantly create
   // an entry in the m_RenderWindowList map. It is possible if the user is
   // regularly calling AddRenderer and RemoveRenderer for a rendering update
   // to come into this method with a renderWindow pointer that is valid in the
   // sense that the window does exist within the application, but that
   // renderWindow has been temporarily removed from this RenderingManager for
   // performance reasons.
   if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
   {
     return;
   }
 
   m_RenderWindowList[renderWindow] = RENDERING_REQUESTED;
 
   if ( !m_UpdatePending )
   {
     m_UpdatePending = true;
     this->GenerateRenderingRequestEvent();
   }
 }
 
 
 void
 RenderingManager
 ::ForceImmediateUpdate( vtkRenderWindow *renderWindow )
 {
   // If the renderWindow is not valid, we do not want to inadvertantly create
   // an entry in the m_RenderWindowList map. It is possible if the user is
   // regularly calling AddRenderer and RemoveRenderer for a rendering update
   // to come into this method with a renderWindow pointer that is valid in the
   // sense that the window does exist within the application, but that
   // renderWindow has been temporarily removed from this RenderingManager for
   // performance reasons.
   if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
   {
     return;
   }
 
   // Erase potentially pending requests for this window
   m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
 
   m_UpdatePending = false;
 
   // Immediately repaint this window (implementation platform specific)
   // If the size is 0 it crahses
   int *size = renderWindow->GetSize();
   if ( 0 != size[0] && 0 != size[1] )
   {
     //prepare the camera etc. before rendering
     //Note: this is a very important step which should be called before the VTK render!
     //If you modify the camera anywhere else or after the render call, the scene cannot be seen.
     mitk::VtkPropRenderer *vPR =
         dynamic_cast<mitk::VtkPropRenderer*>(mitk::BaseRenderer::GetInstance( renderWindow ));
     if(vPR)
        vPR->PrepareRender();
     // Execute rendering
     renderWindow->Render();
   }
 }
 
 
 void
 RenderingManager
 ::RequestUpdateAll( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
        this->RequestUpdate( it->first );
     }
   }
 }
 
 
 void
 RenderingManager
 ::ForceImmediateUpdateAll( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
       // Immediately repaint this window (implementation platform specific)
       // If the size is 0, it crashes
       this->ForceImmediateUpdate(it->first);
-
-  //    int *size = it->first->GetSize();
-  //    if ( 0 != size[0] && 0 != size[1] )
-  //    {
-  //      //prepare the camera before rendering
-  //      //Note: this is a very important step which should be called before the VTK render!
-  //      //If you modify the camera anywhere else or after the render call, the scene cannot be seen.
-  //      mitk::VtkPropRenderer *vPR =
-  //          dynamic_cast<mitk::VtkPropRenderer*>(mitk::BaseRenderer::GetInstance( it->first ));
-      //      if(vPR)
-      //         vPR->PrepareRender();
-      //      // Execute rendering
-      //      it->first->Render();
-      //    }
-
-      //    it->second = RENDERING_INACTIVE;
     }
   }
 
-  //m_UpdatePending = false;
 }
 
 
-//bool RenderingManager::InitializeViews( const mitk::DataStorage * storage, const DataNode* node = NULL, RequestType type, bool preserveRoughOrientationInWorldSpace )
-//{
-//  mitk::Geometry3D::Pointer geometry;
-//  if ( storage != NULL )
-//  {
-//    geometry = storage->ComputeVisibleBoundingGeometry3D(node, "visible", NULL, "includeInBoundingBox" );
-//
-//    if ( geometry.IsNotNull() )
-//    {
-//      // let's see if we have data with a limited live-span ...
-//      mitk::TimeBounds timebounds = geometry->GetTimeBounds();
-//      if ( timebounds[1] < mitk::ScalarTypeNumericTraits::max() )
-//      {
-//        mitk::ScalarType duration = timebounds[1]-timebounds[0];
-//
-//        mitk::TimeSlicedGeometry::Pointer timegeometry =
-//          mitk::TimeSlicedGeometry::New();
-//        timegeometry->InitializeEvenlyTimed(
-//          geometry, (unsigned int) duration );
-//        timegeometry->SetTimeBounds( timebounds );
-//
-//        timebounds[1] = timebounds[0] + 1.0;
-//        geometry->SetTimeBounds( timebounds );
-//
-//        geometry = timegeometry;
-//      }
-//    }
-//  }
-//
-//  // Use geometry for initialization
-//  return this->InitializeViews( geometry.GetPointer(), type );
-//}
-
 
+//TODO_GOETZ
+// Remove old function, so only this one is working.
 bool
 RenderingManager
 ::InitializeViews( const Geometry3D * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
+{
+  ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
+  propTimeGeometry->Initialize(dynamic_cast<Geometry3D *>(dataGeometry->Clone().GetPointer()), 1);
+  return InitializeViews(propTimeGeometry,type, preserveRoughOrientationInWorldSpace);
+}
+
+
+bool
+RenderingManager
+::InitializeViews( const TimeGeometry * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
 {
   MITK_DEBUG << "initializing views";
 
   bool boundingBoxInitialized = false;
 
-  Geometry3D::ConstPointer geometry = dataGeometry;
+  TimeGeometry::ConstPointer timeGeometry = dataGeometry;
+  TimeGeometry::Pointer modifiedGeometry = NULL;
+  if (dataGeometry!=NULL)
+  {
+    itk::LightObject::Pointer clon = dataGeometry->Clone();
+    modifiedGeometry = dynamic_cast<TimeGeometry *> (clon.GetPointer());
+  }
+
 
+  // //TODO_GOETZ previously this code section has been disabled by
+  // a later asignment to geometry (e.g. timeGeometry)
+  // This has been fixed during Geometry-1-Plattform Project
+  // Propably this code is not working anymore, test!!
+  /*
   if (dataGeometry && preserveRoughOrientationInWorldSpace)
   {
-
     // clone the input geometry
-    Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
     assert(modifiedGeometry.IsNotNull());
 
     // construct an affine transform from it
-    AffineGeometryFrame3D::TransformType::Pointer transform = AffineGeometryFrame3D::TransformType::New();
-    assert( modifiedGeometry->GetIndexToWorldTransform() );
-    transform->SetMatrix( modifiedGeometry->GetIndexToWorldTransform()->GetMatrix() );
-    transform->SetOffset( modifiedGeometry->GetIndexToWorldTransform()->GetOffset() );
+    Geometry3D::TransformType::Pointer transform = Geometry3D::TransformType::New();
+    assert( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform() );
+    transform->SetMatrix( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform()->GetMatrix() );
+    transform->SetOffset( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform()->GetOffset() );
 
     // get transform matrix
-    AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
-      const_cast< AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
-    AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType newMatrix(oldMatrix);
+    Geometry3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
+      const_cast< Geometry3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
+    Geometry3D::TransformType::MatrixType::InternalMatrixType newMatrix(oldMatrix);
 
     // get offset and bound
     Vector3D offset = modifiedGeometry->GetIndexToWorldTransform()->GetOffset();
     Geometry3D::BoundsArrayType oldBounds = modifiedGeometry->GetBounds();
     Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
 
     // get rid of rotation other than pi/2 degree
     for ( unsigned int i = 0; i < 3; ++i )
     {
 
       // i-th column of the direction matrix
       Vector3D currentVector;
       currentVector[0] = oldMatrix(0,i);
       currentVector[1] = oldMatrix(1,i);
       currentVector[2] = oldMatrix(2,i);
 
       // matchingRow will store the row that holds the biggest
       // value in the column
       unsigned int matchingRow = 0;
 
       // maximum value in the column
       float max = std::numeric_limits<float>::min();
 
       // sign of the maximum value (-1 or 1)
       int sign = 1;
 
       // iterate through the column vector
       for (unsigned int dim = 0; dim < 3; ++dim)
       {
         if ( fabs(currentVector[dim]) > max )
         {
           matchingRow = dim;
           max = fabs(currentVector[dim]);
           if(currentVector[dim]<0)
             sign = -1;
           else
             sign = 1;
         }
       }
 
       // in case we found a negative maximum,
       // we negate the column and adjust the offset
       // (in order to run through the dimension in the opposite direction)
       if(sign == -1)
       {
         currentVector *= sign;
         offset += modifiedGeometry->GetAxisVector(i);
       }
 
 
       // matchingRow is now used as column index to place currentVector
       // correctly in the new matrix
       vnl_vector<ScalarType> newMatrixColumn(3);
       newMatrixColumn[0] = currentVector[0];
       newMatrixColumn[1] = currentVector[1];
       newMatrixColumn[2] = currentVector[2];
       newMatrix.set_column( matchingRow, newMatrixColumn );
 
       // if a column is moved, we also have to adjust the bounding
       // box accordingly, this is done here
       newBounds[2*matchingRow  ] = oldBounds[2*i  ];
       newBounds[2*matchingRow+1] = oldBounds[2*i+1];
     }
 
     // set the newly calculated bounds array
     modifiedGeometry->SetBounds(newBounds);
 
     // set new offset and direction matrix
-    AffineGeometryFrame3D::TransformType::MatrixType newMatrixITK( newMatrix );
+    Geometry3D::TransformType::MatrixType newMatrixITK( newMatrix );
     transform->SetMatrix( newMatrixITK );
     transform->SetOffset( offset );
     modifiedGeometry->SetIndexToWorldTransform( transform );
     geometry = modifiedGeometry;
 
-  }
+  }*/
 
   int warningLevel = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
-  if ( (geometry.IsNotNull() ) && (const_cast< mitk::BoundingBox * >(
-    geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
+  if ( (timeGeometry.IsNotNull() ) && (const_cast< mitk::BoundingBox * >(
+    timeGeometry->GetBoundingBoxInWorld())->GetDiagonalLength2() > mitk::eps) )
   {
     boundingBoxInitialized = true;
   }
 
-  if (geometry.IsNotNull() )
+  if (timeGeometry.IsNotNull() )
   {// make sure bounding box has an extent bigger than zero in any direction
     // clone the input geometry
-    Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
+    //Old Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
     assert(modifiedGeometry.IsNotNull());
-    Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
-    for( unsigned int dimension = 0; ( 2 * dimension ) < newBounds.Size() ; dimension++ )
+    for (TimeStepType step = 0; step < modifiedGeometry->GetNumberOfTimeSteps(); ++step)
     {
-      //check for equality but for an epsilon
-      if( Equal( newBounds[ 2 * dimension ], newBounds[ 2 * dimension + 1 ] ) )
+      Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetGeometryForTimeStep(step)->GetBounds();
+      for( unsigned int dimension = 0; ( 2 * dimension ) < newBounds.Size() ; dimension++ )
       {
-        newBounds[ 2 * dimension + 1 ] += 1;
+        //check for equality but for an epsilon
+        if( Equal( newBounds[ 2 * dimension ], newBounds[ 2 * dimension + 1 ] ) )
+        {
+          newBounds[ 2 * dimension + 1 ] += 1;
+        }
       }
+      modifiedGeometry->GetGeometryForTimeStep(step)->SetBounds(newBounds);
     }
-
-    // set the newly calculated bounds array
-    modifiedGeometry->SetBounds(newBounds);
-
-    geometry = modifiedGeometry;
   }
 
+  timeGeometry = modifiedGeometry;
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( it->first );
 
     baseRenderer->GetDisplayGeometry()->SetConstrainZoomingAndPanning(m_ConstrainedPaddingZooming);
 
     int id = baseRenderer->GetMapperID();
     if ( ((type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
       )
     {
-      this->InternalViewInitialization( baseRenderer, geometry,
+      this->InternalViewInitialization( baseRenderer, timeGeometry,
         boundingBoxInitialized, id );
     }
   }
 
   if ( boundingBoxInitialized )
   {
-    m_TimeNavigationController->SetInputWorldGeometry( geometry );
+    m_TimeNavigationController->SetInputWorldTimeGeometry( timeGeometry );
   }
   m_TimeNavigationController->Update();
 
   this->RequestUpdateAll( type );
 
   vtkObject::SetGlobalWarningDisplay( warningLevel );
 
   // Inform listeners that views have been initialized
   this->InvokeEvent( mitk::RenderingManagerViewsInitializedEvent() );
 
 
   return boundingBoxInitialized;
 }
 
 
 bool
 RenderingManager
 ::InitializeViews( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( it->first );
     int id = baseRenderer->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
 
       mitk::SliceNavigationController *nc =
 
       baseRenderer->GetSliceNavigationController();
 
       // Re-initialize view direction
       nc->SetViewDirectionToDefault();
 
       // Update the SNC
       nc->Update();
     }
   }
 
   this->RequestUpdateAll( type );
 
   return true;
 }
 
-//bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const DataStorage* ds, const DataNode node = NULL,  bool initializeGlobalTimeSNC )
-//{
-//  mitk::Geometry3D::Pointer geometry;
-//  if ( ds != NULL )
-//  {
-//    geometry = ds->ComputeVisibleBoundingGeometry3D(node, NULL, "includeInBoundingBox" );
-//
-//    if ( geometry.IsNotNull() )
-//    {
-//      // let's see if we have data with a limited live-span ...
-//      mitk::TimeBounds timebounds = geometry->GetTimeBounds();
-//      if ( timebounds[1] < mitk::ScalarTypeNumericTraits::max() )
-//      {
-//        mitk::ScalarType duration = timebounds[1]-timebounds[0];
-//
-//        mitk::TimeSlicedGeometry::Pointer timegeometry =
-//          mitk::TimeSlicedGeometry::New();
-//        timegeometry->InitializeEvenlyTimed(
-//          geometry, (unsigned int) duration );
-//        timegeometry->SetTimeBounds( timebounds );
-//
-//        timebounds[1] = timebounds[0] + 1.0;
-//        geometry->SetTimeBounds( timebounds );
-//
-//        geometry = timegeometry;
-//      }
-//    }
-//  }
-//
-//  // Use geometry for initialization
-//  return this->InitializeView( renderWindow,
-//    geometry.GetPointer(), initializeGlobalTimeSNC );
-//}
-
 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const Geometry3D * geometry, bool initializeGlobalTimeSNC )
+{
+  ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
+  propTimeGeometry->Initialize(dynamic_cast<Geometry3D *>(geometry->Clone().GetPointer()), 1);
+  return InitializeView(renderWindow, propTimeGeometry, initializeGlobalTimeSNC );
+}
+
+bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const TimeGeometry * geometry, bool initializeGlobalTimeSNC )
 {
   bool boundingBoxInitialized = false;
 
   int warningLevel = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   if ( (geometry != NULL ) && (const_cast< mitk::BoundingBox * >(
-   geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
+   geometry->GetBoundingBoxInWorld())->GetDiagonalLength2() > mitk::eps) )
   {
    boundingBoxInitialized = true;
   }
 
   mitk::BaseRenderer *baseRenderer =
    mitk::BaseRenderer::GetInstance( renderWindow );
 
   int id = baseRenderer->GetMapperID();
 
   this->InternalViewInitialization( baseRenderer, geometry,
    boundingBoxInitialized, id );
 
   if ( boundingBoxInitialized && initializeGlobalTimeSNC )
   {
-    m_TimeNavigationController->SetInputWorldGeometry( geometry );
+    m_TimeNavigationController->SetInputWorldTimeGeometry( geometry );
   }
   m_TimeNavigationController->Update();
 
   this->RequestUpdate( renderWindow );
 
   vtkObject::SetGlobalWarningDisplay( warningLevel );
 
   return boundingBoxInitialized;
 }
 
 
 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow )
 {
   mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( renderWindow );
 
   mitk::SliceNavigationController *nc =
     baseRenderer->GetSliceNavigationController();
 
   // Re-initialize view direction
   nc->SetViewDirectionToDefault();
 
   // Update the SNC
   nc->Update();
 
   this->RequestUpdate( renderWindow );
 
   return true;
 }
 
-
-void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer, const mitk::Geometry3D *geometry, bool boundingBoxInitialized, int mapperID )
+void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer, const mitk::TimeGeometry *geometry, bool boundingBoxInitialized, int mapperID )
 {
   mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
 
   // Re-initialize view direction
   nc->SetViewDirectionToDefault();
 
   if ( boundingBoxInitialized )
   {
     // Set geometry for NC
-    nc->SetInputWorldGeometry( geometry );
+    nc->SetInputWorldTimeGeometry( geometry );
     nc->Update();
 
     if ( mapperID == 1 )
     {
       // For 2D SNCs, steppers are set so that the cross is centered
       // in the image
       nc->GetSlice()->SetPos( nc->GetSlice()->GetSteps() / 2 );
     }
 
     // Fit the render window DisplayGeometry
     baseRenderer->GetDisplayGeometry()->Fit();
     baseRenderer->GetCameraController()->SetViewToAnterior();
   }
   else
   {
     nc->Update();
   }
 }
 
 
 const SliceNavigationController* RenderingManager::GetTimeNavigationController() const
 {
   return m_TimeNavigationController.GetPointer();
 }
 
 
 SliceNavigationController* RenderingManager::GetTimeNavigationController()
 {
   return m_TimeNavigationController.GetPointer();
 }
 
 
 void RenderingManager::ExecutePendingRequests()
 {
   m_UpdatePending = false;
 
   // Satisfy all pending update requests
   RenderWindowList::iterator it;
   int i = 0;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it, ++i )
   {
     if ( it->second == RENDERING_REQUESTED )
     {
       this->ForceImmediateUpdate( it->first );
     }
   }
 }
 
 
 void RenderingManager::RenderingStartCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
   RenderWindowList &renderWindowList = renman->m_RenderWindowList;
 
   if ( renderWindow )
   {
     renderWindowList[renderWindow] = RENDERING_INPROGRESS;
   }
 
   renman->m_UpdatePending = false;
 }
 
 
 void
 RenderingManager
 ::RenderingProgressCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
 
   if ( renman->m_LODAbortMechanismEnabled )
   {
     vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
     if ( renderWindow )
     {
       BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
       if ( renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) )
       {
         renman->DoMonitorRendering();
       }
     }
   }
 }
 
 void
 RenderingManager
 ::RenderingEndCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
 
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
 
   RenderWindowList &renderWindowList = renman->m_RenderWindowList;
 
   RendererIntMap &nextLODMap = renman->m_NextLODMap;
 
   if ( renderWindow )
   {
     BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
     if ( renderer )
     {
       renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE;
 
       // Level-of-Detail handling
       if ( renderer->GetNumberOfVisibleLODEnabledMappers() > 0 )
       {
         if(nextLODMap[renderer]==0)
           renman->StartOrResetTimer();
         else
           nextLODMap[renderer] = 0;
       }
     }
   }
 }
 
 
 bool
 RenderingManager
 ::IsRendering() const
 {
   RenderWindowList::const_iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     if ( it->second == RENDERING_INPROGRESS )
     {
       return true;
     }
   }
   return false;
 }
 
 
 void
 RenderingManager
 ::AbortRendering()
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     if ( it->second == RENDERING_INPROGRESS )
     {
       it->first->SetAbortRender( true );
       m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true;
     }
   }
 }
 
 
 int
 RenderingManager
 ::GetNextLOD( BaseRenderer *renderer )
 {
   if ( renderer != NULL )
   {
     return m_NextLODMap[renderer];
   }
   else
   {
     return 0;
   }
 }
 
 
 void
 RenderingManager
 ::ExecutePendingHighResRenderingRequest()
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     BaseRenderer *renderer = BaseRenderer::GetInstance( it->first );
 
     if(renderer->GetNumberOfVisibleLODEnabledMappers()>0)
     {
       if(m_NextLODMap[renderer]==0)
       {
         m_NextLODMap[renderer]=1;
         RequestUpdate( it->first );
       }
     }
   }
 }
 
 void
 RenderingManager
 ::SetMaximumLOD( unsigned int max )
 {
   m_MaxLOD = max;
 }
 
 
 //enable/disable shading
 void
 RenderingManager
 ::SetShading(bool state, unsigned int lod)
 {
   if(lod>m_MaxLOD)
   {
     itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
     return;
   }
   m_ShadingEnabled[lod] = state;
 
 }
 
 bool
 RenderingManager
 ::GetShading(unsigned int lod)
 {
   if(lod>m_MaxLOD)
   {
     itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
     return false;
   }
   return m_ShadingEnabled[lod];
 }
 
 
 //enable/disable the clipping plane
 void
 RenderingManager
 ::SetClippingPlaneStatus(bool status)
 {
   m_ClippingPlaneEnabled = status;
 }
 
 
 bool
 RenderingManager
 ::GetClippingPlaneStatus()
 {
   return m_ClippingPlaneEnabled;
 }
 
 
 void
 RenderingManager
 ::SetShadingValues(float ambient, float diffuse, float specular, float specpower)
 {
   m_ShadingValues[0] = ambient;
   m_ShadingValues[1] = diffuse;
   m_ShadingValues[2] = specular;
   m_ShadingValues[3] = specpower;
 }
 
 
 RenderingManager::FloatVector &
 RenderingManager
 ::GetShadingValues()
 {
   return m_ShadingValues;
 }
 
 void RenderingManager::SetDepthPeelingEnabled( bool enabled )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
     baseRenderer->SetDepthPeelingEnabled(enabled);
   }
 }
 
 void RenderingManager::SetMaxNumberOfPeels( int maxNumber )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
     baseRenderer->SetMaxNumberOfPeels(maxNumber);
   }
 }
 
 void RenderingManager::InitializePropertyList()
 {
   if (m_PropertyList.IsNull())
   {
     m_PropertyList = PropertyList::New();
   }
 
   this->SetProperty("coupled-zoom", BoolProperty::New(false));
   this->SetProperty("coupled-plane-rotation", BoolProperty::New(false));
   this->SetProperty("MIP-slice-rendering", BoolProperty::New(false));
 }
 
 PropertyList::Pointer RenderingManager::GetPropertyList() const
 {
   return m_PropertyList;
 }
 
 BaseProperty* RenderingManager::GetProperty(const char *propertyKey) const
 {
   return m_PropertyList->GetProperty(propertyKey);
 }
 
 void RenderingManager::SetProperty(const char *propertyKey, BaseProperty* propertyValue)
 {
   m_PropertyList->SetProperty(propertyKey, propertyValue);
 }
 
 
 void RenderingManager::SetDataStorage( DataStorage* storage )
 {
   if ( storage != NULL )
   {
     m_DataStorage = storage;
 
     RenderingManager::RenderWindowVector::iterator iter;
     for ( iter = m_AllRenderWindows.begin(); iter<m_AllRenderWindows.end(); iter++ )
     {
       mitk::BaseRenderer::GetInstance( (*iter) )->SetDataStorage( m_DataStorage.GetPointer() );
     }
   }
 }
 
 mitk::DataStorage* RenderingManager::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 
 void RenderingManager::SetGlobalInteraction( mitk::GlobalInteraction* globalInteraction )
 {
   if ( globalInteraction != NULL )
   {
     m_GlobalInteraction = globalInteraction;
   }
 }
 
 mitk::GlobalInteraction* RenderingManager::GetGlobalInteraction()
 {
   return m_GlobalInteraction;
 }
 
 // Create and register generic RenderingManagerFactory.
 TestingRenderingManagerFactory renderingManagerFactory;
 
 
 } // namespace
diff --git a/Core/Code/Controllers/mitkRenderingManager.h b/Core/Code/Controllers/mitkRenderingManager.h
index 570ecb9da3..0103dbd372 100644
--- a/Core/Code/Controllers/mitkRenderingManager.h
+++ b/Core/Code/Controllers/mitkRenderingManager.h
@@ -1,414 +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 MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
 #define MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
 
 #include <MitkExports.h>
 
 #include <vtkCallbackCommand.h>
 
 #include <string>
 #include <itkObject.h>
 #include <itkObjectFactory.h>
 
 #include "mitkPropertyList.h"
 #include "mitkProperties.h"
+#include "mitkTimeGeometry.h"
 
 class vtkRenderWindow;
 class vtkObject;
 
 namespace mitk
 {
 
 class RenderingManager;
 class RenderingManagerFactory;
 class Geometry3D;
 class SliceNavigationController;
 class BaseRenderer;
 class DataStorage;
 class GlobalInteraction;
 
 /**
  * \brief Manager for coordinating the rendering process.
  *
  * RenderingManager is a central instance retrieving and executing
  * RenderWindow update requests. Its main purpose is to coordinate
  * distributed requests which cannot be aware of each other - lacking the
  * knowledge of whether they are really necessary or not. For example, two
  * objects might determine that a specific RenderWindow needs to be updated.
  * This would result in one unnecessary update, if both executed the update
  * on their own.
  *
  * The RenderingManager addresses this by letting each such object
  * <em>request</em> an update, and waiting for other objects to possibly
  * issue the same request. The actual update will then only be executed at a
  * well-defined point in the main event loop (this may be each time after
  * event processing is done).
  *
  * Convinience methods for updating all RenderWindows which have been
  * registered with the RenderingManager exist. If theses methods are not
  * used, it is not required to register (add) RenderWindows prior to using
  * the RenderingManager.
  *
  * The methods #ForceImmediateUpdate() and #ForceImmediateUpdateAll() can
  * be used to force the RenderWindow update execution without any delay,
  * bypassing the request functionality.
  *
  * The interface of RenderingManager is platform independent. Platform
  * specific subclasses have to be implemented, though, to supply an
  * appropriate event issueing for controlling the update execution process.
  * See method documentation for a description of how this can be done.
  *
  * \sa TestingRenderingManager An "empty" RenderingManager implementation which
  * can be used in tests etc.
  *
  */
 class MITK_CORE_EXPORT RenderingManager : public itk::Object
 {
 public:
 
   mitkClassMacro(RenderingManager,itk::Object);
 
   typedef std::vector< vtkRenderWindow* > RenderWindowVector;
   typedef std::vector< float > FloatVector;
   typedef std::vector< bool > BoolVector;
 
   typedef itk::SmartPointer< DataStorage > DataStoragePointer;
   typedef itk::SmartPointer< GlobalInteraction > GlobalInteractionPointer;
 
   enum RequestType
   {
     REQUEST_UPDATE_ALL = 0,
     REQUEST_UPDATE_2DWINDOWS,
     REQUEST_UPDATE_3DWINDOWS
   };
 
 
   static Pointer New();
 
   /** Set the object factory which produces the desired platform specific
    * RenderingManager singleton instance. */
   static void SetFactory( RenderingManagerFactory *factory );
 
   /** Get the object factory which produces the platform specific
    * RenderingManager instances. */
   static const RenderingManagerFactory *GetFactory();
 
   /** Returns true if a factory has already been set. */
   static bool HasFactory();
 
   /** Get the RenderingManager singleton instance. */
   static RenderingManager *GetInstance();
 
   /** Returns true if the singleton instance does already exist. */
   static bool IsInstantiated();
 
   /** Adds a RenderWindow. This is required if the methods #RequestUpdateAll
    * or #ForceImmediateUpdate are to be used. */
   void AddRenderWindow( vtkRenderWindow *renderWindow );
 
   /** Removes a RenderWindow. */
   void RemoveRenderWindow( vtkRenderWindow *renderWindow );
 
   /** Get a list of all registered RenderWindows */
   const RenderWindowVector &GetAllRegisteredRenderWindows();
 
     /** Requests an update for the specified RenderWindow, to be executed as
    * soon as the main loop is ready for rendering. */
   void RequestUpdate( vtkRenderWindow *renderWindow );
 
   /** Immediately executes an update of the specified RenderWindow. */
   void ForceImmediateUpdate( vtkRenderWindow *renderWindow );
 
   /** Requests all currently registered RenderWindows to be updated.
    * If only 2D or 3D windows should be updated, this can be specified
    * via the parameter requestType. */
   void RequestUpdateAll( RequestType type = REQUEST_UPDATE_ALL );
 
 
   /** Immediately executes an update of all registered RenderWindows.
    * If only 2D or 3D windows should be updated, this can be specified
    * via the parameter requestType. */
   void ForceImmediateUpdateAll( RequestType type = REQUEST_UPDATE_ALL );
 
   /** Initializes the windows specified by requestType to the geometry of the
    * given DataStorage. */
   //virtual bool InitializeViews( const DataStorage *storage, const DataNode* node = NULL,
   //   RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );
 
   /** Initializes the windows specified by requestType to the given
    * geometry. PLATFORM SPECIFIC. TODO: HOW IS THIS PLATFORM SPECIFIC? */
   virtual bool InitializeViews( const Geometry3D *geometry,
     RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );
+  virtual bool InitializeViews( const TimeGeometry *geometry,
+    RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );
 
 
   /** Initializes the windows to the default viewing direction
    * (geomtry information is NOT changed). PLATFORM SPECIFIC. */
   virtual bool InitializeViews( RequestType type = REQUEST_UPDATE_ALL );
 
 
   /** Initializes the specified window to the geometry of the given
    * DataNode. Set "initializeGlobalTimeSNC" to true in order to use this
-   * geometry as global TimeSlicedGeometry. PLATFORM SPECIFIC. */
+   * geometry as global TimeGeometry. PLATFORM SPECIFIC. */
   //virtual bool InitializeView( vtkRenderWindow *renderWindow, const DataStorage* ds, const DataNode* node = NULL, bool initializeGlobalTimeSNC = false );
 
   /** Initializes the specified window to the given geometry. Set
    * "initializeGlobalTimeSNC" to true in order to use this geometry as
-   * global TimeSlicedGeometry. PLATFORM SPECIFIC. */
+   * global TimeGeometry. PLATFORM SPECIFIC. */
   virtual bool InitializeView( vtkRenderWindow *renderWindow, const Geometry3D *geometry, bool initializeGlobalTimeSNC = false);
+  virtual bool InitializeView( vtkRenderWindow *renderWindow, const TimeGeometry *geometry, bool initializeGlobalTimeSNC = false);
 
   /** Initializes the specified window to the default viewing direction
    * (geomtry information is NOT changed). PLATFORM SPECIFIC. */
   virtual bool InitializeView( vtkRenderWindow *renderWindow );
 
   /** Gets the (global) SliceNavigationController responsible for
    * time-slicing. */
   const SliceNavigationController *GetTimeNavigationController() const;
 
   /** Gets the (global) SliceNavigationController responsible for
    * time-slicing. */
   SliceNavigationController *GetTimeNavigationController();
 
   virtual ~RenderingManager();
 
   /** Executes all pending requests. This method has to be called by the
    * system whenever a RenderingManager induced request event occurs in
    * the system pipeline (see concrete RenderingManager implementations). */
   virtual void ExecutePendingRequests();
 
   bool IsRendering() const;
   void AbortRendering();
 
   /** En-/Disable LOD increase globally. */
   itkSetMacro( LODIncreaseBlocked, bool );
 
   /** En-/Disable LOD increase globally. */
   itkGetMacro( LODIncreaseBlocked, bool );
 
   /** En-/Disable LOD increase globally. */
   itkBooleanMacro( LODIncreaseBlocked );
 
 
   /** En-/Disable LOD abort mechanism. */
   itkSetMacro( LODAbortMechanismEnabled, bool );
 
   /** En-/Disable LOD abort mechanism. */
   itkGetMacro( LODAbortMechanismEnabled, bool );
 
   /** En-/Disable LOD abort mechanism. */
   itkBooleanMacro( LODAbortMechanismEnabled );
 
   /** En-/Disable depth peeling for all renderers */
   void SetDepthPeelingEnabled(bool enabled);
 
   /** Set maximum number of peels for all renderers */
   void SetMaxNumberOfPeels(int maxNumber);
 
   /** Force a sub-class to start a timer for a pending hires-rendering request */
   virtual void StartOrResetTimer() {};
 
   /** To be called by a sub-class from a timer callback */
   void ExecutePendingHighResRenderingRequest();
 
 
   virtual void DoStartRendering() {};
   virtual void DoMonitorRendering() {};
   virtual void DoFinishAbortRendering() {};
 
   int GetNextLOD( BaseRenderer* renderer );
 
   /** Set current LOD (NULL means all renderers)*/
   void SetMaximumLOD( unsigned int max );
 
   void SetShading( bool state, unsigned int lod );
   bool GetShading( unsigned int lod );
 
   void SetClippingPlaneStatus( bool status );
   bool GetClippingPlaneStatus();
 
   void SetShadingValues( float ambient, float diffuse,
     float specular, float specpower );
 
   FloatVector &GetShadingValues();
 
   /** Returns a property list */
   PropertyList::Pointer GetPropertyList() const;
 
   /** Returns a property from m_PropertyList */
   BaseProperty* GetProperty(const char *propertyKey) const;
 
   /** Sets or adds (if not present) a property in m_PropertyList  */
   void SetProperty(const char *propertyKey, BaseProperty* propertyValue);
 
   /**
   * \brief Setter / Getter for internal DataStorage
   *
   * Sets / returns the mitk::DataStorage that is used internally. This instance holds all mitk::DataNodes that are
   * rendered by the registered BaseRenderers.
   *
   * If this DataStorage is changed at runtime by calling SetDataStorage(),
   * all currently registered BaseRenderers are automatically given the correct instance.
   * When a new BaseRenderer is added, it is automatically initialized with the currently active DataStorage.
   */
   void SetDataStorage( mitk::DataStorage* storage );
 
   /**
   * \brief Setter / Getter for internal DataStorage
   *
   * Sets / returns the mitk::DataStorage that is used internally. This instance holds all mitk::DataNodes that are
   * rendered by the registered BaseRenderers.
   *
   * If this DataStorage is changed at runtime by calling SetDataStorage(),
   * all currently registered BaseRenderers are automatically given the correct instance.
   * When a new BaseRenderer is added, it is automatically initialized with the currently active DataStorage.
   */
   mitk::DataStorage* GetDataStorage();
 
 
   /**
   * \brief Setter / Getter for internal GloabInteraction
   *
   * Sets / returns the instance of mitk::GlobalInteraction that is internally held.
   * It'S not actually used by this class but offers it to all registered BaseRenderers.
   * These need it for their own internal initialization of the FocusManager and the corresponding EventMappers.
   */
   void SetGlobalInteraction( mitk::GlobalInteraction* globalInteraction );
 
   /**
   * \brief Setter / Getter for internal GloabInteraction
   *
   * Sets / returns the instance of mitk::GlobalInteraction that is internally held.
   * It'S not actually used by this class but offers it to all registered BaseRenderers.
   * These need it for their own internal initialization of the FocusManager and the corresponding EventMappers.
   */
   mitk::GlobalInteraction* GetGlobalInteraction();
 
   itkSetMacro(ConstrainedPaddingZooming, bool);
 
 protected:
   enum
   {
     RENDERING_INACTIVE = 0,
     RENDERING_REQUESTED,
     RENDERING_INPROGRESS
   };
 
   RenderingManager();
 
   /** Abstract method for generating a system specific event for rendering
    * request. This method is called whenever an update is requested */
   virtual void GenerateRenderingRequestEvent() = 0;
 
   virtual void InitializePropertyList();
 
   bool m_UpdatePending;
 
   typedef std::map< BaseRenderer *, unsigned int > RendererIntMap;
   typedef std::map< BaseRenderer *, bool > RendererBoolMap;
 
 
   RendererBoolMap m_RenderingAbortedMap;
 
   RendererIntMap m_NextLODMap;
 
   unsigned int m_MaxLOD;
 
   bool m_LODIncreaseBlocked;
 
   bool m_LODAbortMechanismEnabled;
 
   BoolVector m_ShadingEnabled;
 
   bool m_ClippingPlaneEnabled;
 
   FloatVector m_ShadingValues;
 
   static void RenderingStartCallback(
     vtkObject *caller, unsigned long eid, void *clientdata, void *calldata );
   static void RenderingProgressCallback(
     vtkObject *caller, unsigned long eid, void *clientdata, void *calldata );
   static void RenderingEndCallback(
     vtkObject *caller, unsigned long eid, void *clientdata, void *calldata );
 
   typedef std::map< vtkRenderWindow *, int > RenderWindowList;
 
   RenderWindowList m_RenderWindowList;
   RenderWindowVector m_AllRenderWindows;
 
   struct RenderWindowCallbacks
   {
     vtkCallbackCommand* commands[3u];
   };
 
   typedef std::map<vtkRenderWindow*, RenderWindowCallbacks> RenderWindowCallbacksList;
 
   RenderWindowCallbacksList m_RenderWindowCallbacksList;
 
   itk::SmartPointer<SliceNavigationController> m_TimeNavigationController;
 
   static RenderingManager::Pointer s_Instance;
   static RenderingManagerFactory *s_RenderingManagerFactory;
 
   PropertyList::Pointer m_PropertyList;
 
   DataStoragePointer m_DataStorage;
 
   GlobalInteractionPointer m_GlobalInteraction;
 
   bool m_ConstrainedPaddingZooming;
 
 private:
 
   void InternalViewInitialization(
-      mitk::BaseRenderer *baseRenderer, const mitk::Geometry3D *geometry,
+      mitk::BaseRenderer *baseRenderer, const mitk::TimeGeometry *geometry,
       bool boundingBoxInitialized, int mapperID );
 
 };
 
 #pragma GCC visibility push(default)
 
 itkEventMacro( RenderingManagerEvent, itk::AnyEvent );
 itkEventMacro( RenderingManagerViewsInitializedEvent, RenderingManagerEvent );
 
 #pragma GCC visibility pop
 
 /**
  * Generic RenderingManager implementation for "non-rendering-plattform",
  * e.g. for tests. Its factory (TestingRenderingManagerFactory) is
  * automatically on start-up and is used by default if not other
  * RenderingManagerFactory is instantiated explicitly thereafter.
  * (see mitkRenderingManager.cpp)
  */
 class MITK_CORE_EXPORT TestingRenderingManager : public RenderingManager
 {
 public:
   mitkClassMacro(TestingRenderingManager,RenderingManager);
   itkNewMacro(Self);
 
 protected:
   virtual void GenerateRenderingRequestEvent()
   {
    // ForceImmediateUpdateAll();
   };
 
 };
 
 
 } // namespace mitk
 
 #endif /* MITKRenderingManager_H_HEADER_INCLUDED_C135A197 */
diff --git a/Core/Code/Controllers/mitkSliceNavigationController.cpp b/Core/Code/Controllers/mitkSliceNavigationController.cpp
index 3e91b3e586..fca6a8d591 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,772 +1,803 @@
 /*===================================================================
 
 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 "mitkMemoryUtilities.h"
 
 
 #include <itkCommand.h>
 
 namespace mitk {
 
 SliceNavigationController::SliceNavigationController( const char *type )
 : BaseController( type ),
-  m_InputWorldGeometry( NULL ),
+  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::SetInputWorldGeometry( const Geometry3D *geometry )
+SliceNavigationController::SetInputWorldGeometry3D( const Geometry3D *geometry )
 {
   if ( geometry != NULL )
   {
     if ( const_cast< BoundingBox * >( geometry->GetBoundingBox())
          ->GetDiagonalLength2() < eps )
     {
       itkWarningMacro( "setting an empty bounding-box" );
       geometry = NULL;
     }
   }
-  if ( m_InputWorldGeometry != geometry )
+  if ( m_InputWorldGeometry3D != geometry )
   {
-    m_InputWorldGeometry = 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;
 }
 
 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 )
 {
-  const TimeSlicedGeometry* worldTimeSlicedGeometry =
-    dynamic_cast< const TimeSlicedGeometry * >(
-      m_InputWorldGeometry.GetPointer() );
+  TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
 
   if( m_BlockUpdate ||
-      m_InputWorldGeometry.IsNull() ||
-      ( (worldTimeSlicedGeometry != NULL) && (worldTimeSlicedGeometry->GetTimeSteps() == 0) )
+      ( m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull() ) ||
+      ( (worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->GetNumberOfTimeSteps() == 0) )
     )
   {
     return;
   }
 
   m_BlockUpdate = true;
 
-  if ( m_LastUpdateTime < m_InputWorldGeometry->GetMTime() )
+  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;
+    Geometry3D::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 ( worldTimeSlicedGeometry != NULL )
+      if ( worldTimeGeometry.IsNotNull())
       {
-        m_CreatedWorldGeometry = static_cast< TimeSlicedGeometry * >(
-          m_InputWorldGeometry->Clone().GetPointer() );
+        itk::LightObject::Pointer cloned = worldTimeGeometry->Clone();
+        m_CreatedWorldGeometry = dynamic_cast<TimeGeometry *> (cloned.GetPointer());
 
-        worldTimeSlicedGeometry = m_CreatedWorldGeometry.GetPointer();
+        worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
 
         slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
-          m_CreatedWorldGeometry->GetGeometry3D( this->GetTime()->GetPos() ) );
+          m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).GetPointer() );
 
         if ( slicedWorldGeometry.IsNotNull() )
         {
           break;
         }
       }
       else
       {
         const SlicedGeometry3D *worldSlicedGeometry =
           dynamic_cast< const SlicedGeometry3D * >(
-            m_InputWorldGeometry.GetPointer());
+            currentGeometry.GetPointer());
 
         if ( worldSlicedGeometry != NULL )
         {
           slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
-            m_InputWorldGeometry->Clone().GetPointer());
+            currentGeometry->Clone().GetPointer());
           break;
         }
       }
       //else: use Axial: no "break" here!!
 
     case Axial:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes(
-        m_InputWorldGeometry, PlaneGeometry::Axial,
+        currentGeometry, PlaneGeometry::Axial,
         top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Frontal:
       slicedWorldGeometry = SlicedGeometry3D::New();
-      slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
+      slicedWorldGeometry->InitializePlanes( currentGeometry,
         PlaneGeometry::Frontal, top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Sagittal:
       slicedWorldGeometry = SlicedGeometry3D::New();
-      slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
+      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 TimeSlicedGeometry
-      m_CreatedWorldGeometry = TimeSlicedGeometry::New();
+      // initialize TimeGeometry
+      m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
     }
-    if ( worldTimeSlicedGeometry == NULL )
+    if ( worldTimeGeometry.IsNull())
     {
-      m_CreatedWorldGeometry->InitializeEvenlyTimed( slicedWorldGeometry, 1 );
+      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( worldTimeSlicedGeometry->GetTimeSteps() );
+      m_Time->SetSteps( worldTimeGeometry->GetNumberOfTimeSteps() );
       m_Time->SetPos( 0 );
 
-      const TimeBounds &timeBounds = worldTimeSlicedGeometry->GetTimeBounds();
+      const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
       m_Time->SetRange( timeBounds[0], timeBounds[1] );
 
       m_BlockUpdate = false;
 
-      assert( worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() ) != NULL );
+      assert( worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).IsNotNull() );
 
       slicedWorldGeometry->SetTimeBounds(
-        worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() )->GetTimeBounds() );
+        worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() )->GetTimeBounds() );
 
       //@todo implement for non-evenly-timed geometry!
-      m_CreatedWorldGeometry->InitializeEvenlyTimed(
-        slicedWorldGeometry, worldTimeSlicedGeometry->GetTimeSteps() );
+      m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
+      dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, worldTimeGeometry->GetNumberOfTimeSteps());
     }
   }
 
   // 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 );
 
-  TimeSlicedGeometry *timeSlicedGeometry = timeEvent->GetTimeSlicedGeometry();
-  assert( timeSlicedGeometry != NULL );
+  TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
+  assert( timeGeometry != NULL );
 
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
     int timeStep = (int) timeEvent->GetPos();
     ScalarType timeInMS;
-    timeInMS = timeSlicedGeometry->TimeStepToMS( timeStep );
-    timeStep = m_CreatedWorldGeometry->MSToTimeStep( 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->GetGeometry3D( this->GetTime()->GetPos() ) );
+    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::Geometry2D *plane = slicedWorldGeometry->GetGeometry2D( 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 );
         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();
 }
 
-
-
-const mitk::TimeSlicedGeometry *
+mitk::TimeGeometry *
 SliceNavigationController::GetCreatedWorldGeometry()
 {
   return m_CreatedWorldGeometry;
 }
 
-
 const mitk::Geometry3D *
 SliceNavigationController::GetCurrentGeometry3D()
 {
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
-    return m_CreatedWorldGeometry->GetGeometry3D( this->GetTime()->GetPos() );
+    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()) );
     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( (float) direction[i] ) < 0.000000001 ) { ++c; }
     else { k = i; }
   }
 
   if ( c == 2 )
   {
-    ScalarType min = m_InputWorldGeometry->GetOrigin()[k];
-    ScalarType max = min + m_InputWorldGeometry->GetExtentInMM( k );
+    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;
       }
     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 13dc103ed5..676e74cad2 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.h
+++ b/Core/Code/Controllers/mitkSliceNavigationController.h
@@ -1,558 +1,602 @@
 /*===================================================================
 
 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 <MitkExports.h>
 #include "mitkBaseController.h"
 #include "mitkRenderingManager.h"
-#include "mitkTimeSlicedGeometry.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(TimeSlicedGeometry* aTimeSlicedGeometry, unsigned int aPos) \
-     : Superclass(aTimeSlicedGeometry, aPos) {} \
+     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(GetTimeSlicedGeometry(), GetPos()); } \
+       { return new Self(GetTimeGeometry(), GetPos()); } \
    private: \
      void operator=(const Self&); \
  }
 
 class PlaneGeometry;
 class Geometry3D;
 class BaseRenderer;
 
 /**
  * \brief Controls the selection of the slice the associated BaseRenderer
  * will display
  *
- * A SliceNavigationController takes a Geometry3D as input world geometry
- * (TODO what are the exact requirements?) and generates a TimeSlicedGeometry
- * as output. The TimeSlicedGeometry holds a number of SlicedGeometry3Ds and
+ * A SliceNavigationController takes a Geometry3D 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
  * 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
- * Geometry2D from the TimeSlicedGeometry. SliceNavigationController generates
+ * Geometry2D 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)
  * 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);
     itkNewMacro(Self);
     mitkNewMacro1Param(Self, const char *);
 
     /**
      * \brief Possible view directions, \a Original will uses
      * the Geometry2D instances in a SlicedGeometry3D provided
      * as input world geometry (by SetInputWorldGeometry).
      */
     enum ViewDirection
     {
 #ifdef _MSC_VER
       Transversal, // deprecated
 #endif
       Axial = 0,
       Sagittal,
       Frontal,
       Original
     };
 
 #ifdef __GNUC__
     __attribute__ ((deprecated)) static const ViewDirection Transversal = ViewDirection(Axial);
 #endif
 
     /**
-     * \brief Set the input world geometry out of which the
+     * \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::Geometry3D* geometry);
+    itkGetConstObjectMacro(InputWorldGeometry3D, mitk::Geometry3D);
+
+
+    /**
+     * \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_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
      */
-    void SetInputWorldGeometry(const mitk::Geometry3D* geometry);
-    itkGetConstObjectMacro(InputWorldGeometry, mitk::Geometry3D);
+    DEPRECATED(void SetInputWorldGeometry(const mitk::TimeSlicedGeometry* geometry));
+    /**
+     * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
+     */
+    DEPRECATED(TimeSlicedGeometry* GetInputWorldGeometry());
+
+
+    void SetInputWorldTimeGeometry(const mitk::TimeGeometry* geometry);
+    itkGetConstObjectMacro(InputWorldTimeGeometry, mitk::TimeGeometry);
 
     /**
      * \brief Access the created geometry
      */
-    itkGetConstObjectMacro(CreatedWorldGeometry, mitk::Geometry3D);
+    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);
 
     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 TimeSlicedGeometryEvent : public itk::AnyEvent
+    class MITK_CORE_EXPORT TimeGeometryEvent : public itk::AnyEvent
     {
       public:
-        typedef TimeSlicedGeometryEvent Self;
+        typedef TimeGeometryEvent Self;
         typedef itk::AnyEvent Superclass;
 
-        TimeSlicedGeometryEvent(
-          TimeSlicedGeometry* aTimeSlicedGeometry, unsigned int aPos)
-          : m_TimeSlicedGeometry(aTimeSlicedGeometry), m_Pos(aPos)
+        TimeGeometryEvent(
+          TimeGeometry* aTimeGeometry, unsigned int aPos)
+          : m_TimeGeometry(aTimeGeometry), m_Pos(aPos)
           {}
 
-        virtual ~TimeSlicedGeometryEvent()
+        virtual ~TimeGeometryEvent()
           {}
 
         virtual const char * GetEventName() const
-          { return "TimeSlicedGeometryEvent"; }
+          { 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_TimeSlicedGeometry, m_Pos); }
+          { return new Self(m_TimeGeometry, m_Pos); }
 
-        TimeSlicedGeometry* GetTimeSlicedGeometry() const
-          { return m_TimeSlicedGeometry; }
+        TimeGeometry* GetTimeGeometry() const
+          { return m_TimeGeometry; }
 
         unsigned int GetPos() const
           { return m_Pos; }
 
       private:
-        TimeSlicedGeometry::Pointer m_TimeSlicedGeometry;
+        TimeGeometry::Pointer m_TimeGeometry;
         unsigned int m_Pos;
-        // TimeSlicedGeometryEvent(const Self&);
+        // TimeGeometryEvent(const Self&);
         void operator=(const Self&); //just hide
     };
 
-    mitkTimeSlicedGeometryEventMacro(
-      GeometrySendEvent,TimeSlicedGeometryEvent );
-    mitkTimeSlicedGeometryEventMacro(
-      GeometryUpdateEvent, TimeSlicedGeometryEvent );
-    mitkTimeSlicedGeometryEventMacro(
-      GeometryTimeEvent, TimeSlicedGeometryEvent );
-    mitkTimeSlicedGeometryEventMacro(
-      GeometrySliceEvent, TimeSlicedGeometryEvent );
+   /**
+   * \deprecatedSince{2013_06} Please use TimeGeometryEvent instead: For additional information see  @TimeGeometryGuide@
+   */
+   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 TimeSlicedGeometry created by the SNC. */
-    const mitk::TimeSlicedGeometry *GetCreatedWorldGeometry();
-
+    /** \brief Returns the TimeGeometry created by the SNC. */
+    mitk::TimeGeometry *GetCreatedWorldGeometry();
 
     /** \brief Returns the Geometry3D of the currently selected time step. */
     const mitk::Geometry3D *GetCurrentGeometry3D();
 
 
     /** \brief Returns the currently selected Plane in the current
      * Geometry3D (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::Geometry3D::ConstPointer m_InputWorldGeometry;
-    mitk::Geometry3D::Pointer m_ExtendedInputWorldGeometry;
+    mitk::Geometry3D::ConstPointer m_InputWorldGeometry3D;
+    mitk::TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
 
-    mitk::TimeSlicedGeometry::Pointer m_CreatedWorldGeometry;
+    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/mitkSlicesCoordinator.h b/Core/Code/Controllers/mitkSlicesCoordinator.h
index 4b448cd582..6c04ecc434 100644
--- a/Core/Code/Controllers/mitkSlicesCoordinator.h
+++ b/Core/Code/Controllers/mitkSlicesCoordinator.h
@@ -1,118 +1,118 @@
 /*===================================================================
 
 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 SLICESCOORDINATOR_H_HEADER_INCLUDED_C1C55A2F
 #define SLICESCOORDINATOR_H_HEADER_INCLUDED_C1C55A2F
 
 #include <mitkStateMachine.h>
 #include <vector>
 
 namespace mitk {
 
 class SliceNavigationController;
 class Action;
 class StateEvent;
 
 #pragma GCC visibility push(default)
 itkEventMacro( SliceRotationEvent, itk::AnyEvent);
 #pragma GCC visibility pop
 
 /**
  * \brief Coordinates a list of SliceNavigationControllers.
  *
  * Each SliceNavigationController can select one slice from a
- * TimeSlicedGeometry. This class (SlicesCoordinator) coordinates several
+ * TimeGeometry. This class (SlicesCoordinator) coordinates several
  * SliceNavigationControllers to facilitate e.g. rotation of slices. A new
  * class is needed, because for rotation one has to know an axis of rotation.
  * Such an axis is most easily determined from the "other slices", which are
  * not known by a SliceNavigationController.
 
  * This class registers itself as a listener to GlobalInteraction and holds a
  * list of SliceNavigationControllers. Any functionality, such as slice
  * rotation, is done in subclasses. This separation is done for the case that
  * some other multi-slice coordination should be implemented.
  */
 class MITK_CORE_EXPORT SlicesCoordinator : public StateMachine
 {
 public:
 
   typedef std::vector<SliceNavigationController*> SNCVector;
 
   mitkClassMacro(SlicesCoordinator, StateMachine);
   mitkNewMacro1Param(Self, const char*);
 
 
   /** Add to list of managed slices. Check if CreatedWorldGeometry of SNC is
    * managable (i.e. there is basically only one planegeometry) */
   void AddSliceController(SliceNavigationController* snc);
 
   /** Remove one controller, which is then added as listener to
    * GlobalInteraction */
   void RemoveSliceController(SliceNavigationController* snc);
 
   /* Reset all Slices to central slice, no rotation */
   // void ResetAllSlices();
 
   /** Set/Get whether planes should stay linked to each other (by fixing
    * their relative angle) */
   itkSetMacro( LinkPlanes, bool );
   itkGetMacro( LinkPlanes, bool );
   itkBooleanMacro( LinkPlanes );
 
   /** \brief Resets the mouse cursor (if modified by the SlicesCoordinator)
    * to its original state.
    *
    * Should be used by subclasses and from external application instead
    * of using QmitkApplicationCursor directly to avoid conflicts. */
   void ResetMouseCursor();
 
 
 protected:
   /** \brief Default Constructor */
   SlicesCoordinator(const char* machine);
 
   /** clear list of controllers */
   virtual ~SlicesCoordinator();
 
   /** \brief Sets the specified mouse cursor.
    *
    * Use this in subclasses instead of using QmitkApplicationCursor directly.
    */
   void SetMouseCursor( const char *xpm[], int hotspotX, int hotspotY );
 
   /** for implementation in subclasses */
   virtual void OnSliceControllerAdded(SliceNavigationController* snc);
 
   /** for implementation in subclasses */
   virtual void OnSliceControllerRemoved(SliceNavigationController* snc);
 
   /** for implementation in subclasses */
   virtual bool ExecuteAction(Action * action, StateEvent const* stateEvent);
 
   SNCVector m_SliceNavigationControllers;
 
   bool m_LinkPlanes;
 
   bool m_MouseCursorSet;
 
 };
 
 } // namespace
 
 #endif
 
 
diff --git a/Core/Code/Controllers/mitkSlicesRotator.cpp b/Core/Code/Controllers/mitkSlicesRotator.cpp
index b2d66aa13a..92d3480778 100644
--- a/Core/Code/Controllers/mitkSlicesRotator.cpp
+++ b/Core/Code/Controllers/mitkSlicesRotator.cpp
@@ -1,519 +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 <mitkGeometry2D.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkDisplayGeometry.h>
 #include <mitkSlicedGeometry3D.h>
-#include <mitkTimeSlicedGeometry.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 );
 
-    const Geometry3D *geometry3D = rotatedPlaneSNC->GetCreatedWorldGeometry();
-    const TimeSlicedGeometry *timeSlicedGeometry =
-      dynamic_cast<const TimeSlicedGeometry*>( geometry3D );
-    if ( !timeSlicedGeometry )
+    TimeGeometry *timeGeometry= rotatedPlaneSNC->GetCreatedWorldGeometry();
+    if ( !timeGeometry )
     {
       return;
     }
 
-    const_cast< TimeSlicedGeometry * >( timeSlicedGeometry )->ExecuteOperation( &op );
+    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 );
 
-      const Geometry3D* geometry3D = (*iter)->GetCreatedWorldGeometry();
-      const TimeSlicedGeometry *timeSlicedGeometry =
-        dynamic_cast<const TimeSlicedGeometry*>( geometry3D );
-      if ( !timeSlicedGeometry )
+      TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
+      if ( !timeGeometry )
       {
         continue;
       }
 
-      const_cast< TimeSlicedGeometry * >( timeSlicedGeometry )->ExecuteOperation( &op );
+      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 Geometry3D* geometry3D = (*iter)->GetCreatedWorldGeometry();
-    const TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const TimeSlicedGeometry*>( geometry3D );
-    if (!timeSlicedGeometry) continue;
+    const TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
+    if (!timeGeometry) continue;
 
-    const SlicedGeometry3D* slicedGeometry = dynamic_cast<const SlicedGeometry3D*>( timeSlicedGeometry->GetGeometry3D(0) );
+    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() );
   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 );
 
-    const Geometry3D* geometry3D = (*iter)->GetCreatedWorldGeometry();
-    const TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const TimeSlicedGeometry*>(geometry3D);
-    if (!timeSlicedGeometry) continue;
+    TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
+    if (!timeGeometry) continue;
 
-    const_cast<TimeSlicedGeometry*>(timeSlicedGeometry)->ExecuteOperation(&rotationOperation);
+    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 780e78117b..7e815e1c70 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
   choose between rotation and slice selection. Such functionality could not be implemented
   by a single SliceNavigationController.
 
-  Rotation is achieved by modifying (rotating) the generated TimeSlicedGeometry of the
+  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 a3e5230b57..35b415ca1d 100644
--- a/Core/Code/Controllers/mitkSlicesSwiveller.cpp
+++ b/Core/Code/Controllers/mitkSlicesSwiveller.cpp
@@ -1,405 +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 "mitkGeometry2D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkDisplayGeometry.h"
 #include "mitkSlicedGeometry3D.h"
-#include "mitkTimeSlicedGeometry.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 Geometry3D* geometry3D = (*iter)->GetCreatedWorldGeometry();
-    const TimeSlicedGeometry* timeSlicedGeometry =
-      dynamic_cast<const TimeSlicedGeometry*>( geometry3D );
+    const TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
 
-    if (!timeSlicedGeometry) continue;
+    if (!timeGeometry) continue;
 
     const SlicedGeometry3D* slicedGeometry =
       dynamic_cast<const SlicedGeometry3D*>(
-        timeSlicedGeometry->GetGeometry3D(0) );
+        timeGeometry->GetGeometryForTimeStep(0).GetPointer() );
     if (!slicedGeometry) continue;
 
     Geometry2D *firstSlice( NULL );
     //Geometry2D *secondSlice( NULL );
 
     if (slicedGeometry->IsValidSlice(0))
     {
       firstSlice = slicedGeometry->GetGeometry2D(0);
     }
 //    if (slicedGeometry->IsValidSlice(1))
 //    {
 //      secondSlice = slicedGeometry->GetGeometry2D(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() )
         {
-          const Geometry3D* geometry3D = (*iter)->GetCreatedWorldGeometry();
-          const TimeSlicedGeometry* timeSlicedGeometry =
-            dynamic_cast<const TimeSlicedGeometry*>(geometry3D);
-          if (!timeSlicedGeometry) continue;
-
-          const_cast<TimeSlicedGeometry*>(timeSlicedGeometry)
-            ->ExecuteOperation(&op);
+          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 TimeSlicedGeometry of this SliceNavigationController
-          const Geometry3D* geometry3D = (*iter)->GetCreatedWorldGeometry();
-          const TimeSlicedGeometry* timeSlicedGeometry =
-            dynamic_cast<const TimeSlicedGeometry*>(geometry3D);
-          if (!timeSlicedGeometry) continue;
+          // Retrieve the TimeGeometry of this SliceNavigationController
+          TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
+          if (!timeGeometry) continue;
 
           // Execute the new rotation
-          const_cast<TimeSlicedGeometry*>(timeSlicedGeometry)
-            ->ExecuteOperation(&op2);
+          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->Geometry3D::IndexToWorld(
             Vector3D( xVector), m_RotationPlaneXVector );
           clickedGeometry->Geometry3D::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 c01ea9466d..e8ab8d8790 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
  * choose between rotation and slice selection.
  *
  * Rotation is achieved by modifying (rotating) the generated
- * TimeSlicedGeometry of the corresponding SliceNavigationController.
+ * 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/mitkBaseData.cpp b/Core/Code/DataManagement/mitkBaseData.cpp
index 77050f2a9d..80856c8679 100644
--- a/Core/Code/DataManagement/mitkBaseData.cpp
+++ b/Core/Code/DataManagement/mitkBaseData.cpp
@@ -1,283 +1,299 @@
 /*===================================================================
 
 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 "mitkBaseData.h"
+
+#include <mitkProportionalTimeGeometry.h>
 #include <itkObjectFactoryBase.h>
+#include <mitkException.h>
 
 
 mitk::BaseData::BaseData() :
   m_RequestedRegionInitialized(false),
   m_SourceOutputIndexDuplicate(0), m_Initialized(true)
 {
-  m_TimeSlicedGeometry = TimeSlicedGeometry::New();
+  m_TimeGeometry = mitk::ProportionalTimeGeometry::New();
   m_PropertyList = PropertyList::New();
 }
 
 mitk::BaseData::BaseData( const BaseData &other ):
 itk::DataObject(), mitk::OperationActor(),
 m_RequestedRegionInitialized(other.m_RequestedRegionInitialized),
 m_SourceOutputIndexDuplicate(other.m_SourceOutputIndexDuplicate),
 m_Initialized(other.m_Initialized)
 {
-  m_TimeSlicedGeometry = dynamic_cast<mitk::TimeSlicedGeometry*>(other.m_TimeSlicedGeometry->Clone().GetPointer());
+  m_TimeGeometry = dynamic_cast<TimeGeometry *>(other.m_TimeGeometry->Clone().GetPointer());
   m_PropertyList = other.m_PropertyList->Clone();
 }
 
 mitk::BaseData::~BaseData()
 {
 
 }
 
-void mitk::BaseData::InitializeTimeSlicedGeometry(unsigned int timeSteps)
+void mitk::BaseData::InitializeTimeGeometry(unsigned int timeSteps)
 {
-  mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
-
   mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
   g3d->Initialize();
 
  if ( timeSteps > 1 )
  {
     mitk::ScalarType timeBounds[] = {0.0, 1.0};
     g3d->SetTimeBounds( timeBounds );
  }
 
   // The geometry is propagated automatically to the other items,
   // if EvenlyTimed is true...
-  timeGeometry->InitializeEvenlyTimed( g3d.GetPointer(), timeSteps );
+  //Old timeGeometry->InitializeEvenlyTimed( g3d.GetPointer(), timeSteps );
+
+  TimeGeometry::Pointer timeGeometry = this->GetTimeGeometry();
+  timeGeometry->Expand(timeSteps);
+  for (TimeStepType step = 0; step < timeSteps; ++step)
+  {
+    timeGeometry->SetTimeStepGeometry(g3d.GetPointer(),step);
+  }
 }
 
 void mitk::BaseData::UpdateOutputInformation()
 {
   if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
-  if(m_TimeSlicedGeometry.IsNotNull())
-    m_TimeSlicedGeometry->UpdateInformation();
+  if (m_TimeGeometry.IsNotNull())
+  {
+    m_TimeGeometry->UpdateBoundingBox();
+  }
 }
 
-const mitk::TimeSlicedGeometry* mitk::BaseData::GetUpdatedTimeSlicedGeometry()
+const mitk::TimeGeometry* mitk::BaseData::GetUpdatedTimeGeometry()
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
-  return GetTimeSlicedGeometry();
+  return GetTimeGeometry();
 }
 
 void mitk::BaseData::Expand( unsigned int timeSteps )
 {
-  if( m_TimeSlicedGeometry.IsNotNull() )
-    m_TimeSlicedGeometry->ExpandToNumberOfTimeSteps( timeSteps );
+  if (m_TimeGeometry.IsNotNull() )
+  {
+    ProportionalTimeGeometry * propTimeGeometry = dynamic_cast<ProportionalTimeGeometry*> (m_TimeGeometry.GetPointer());
+    if (propTimeGeometry)
+    {
+      propTimeGeometry->Expand(timeSteps);
+      return;
+    }
+
+    mitkThrow() << "TimeGeometry is of an unkown Type. Could not expand it. ";
+  }
+  else
+  {
+    this->InitializeTimeGeometry(timeSteps);
+  }
 }
 
 const mitk::Geometry3D* mitk::BaseData::GetUpdatedGeometry(int t)
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
   return GetGeometry(t);
 }
 
-void mitk::BaseData::SetGeometry(Geometry3D* aGeometry3D)
+void mitk::BaseData::SetGeometry(Geometry3D* geometry)
 {
-if(aGeometry3D!=NULL)
-  {
-    TimeSlicedGeometry::Pointer timeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(aGeometry3D);
-    if ( timeSlicedGeometry.IsNotNull() )
-      m_TimeSlicedGeometry = timeSlicedGeometry;
-    else
-    {
-      timeSlicedGeometry = TimeSlicedGeometry::New();
-      m_TimeSlicedGeometry = timeSlicedGeometry;
-      timeSlicedGeometry->InitializeEvenlyTimed(aGeometry3D, 1);
-    }
-    Modified();
-  }
-  else if( m_TimeSlicedGeometry.IsNotNull() )
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  if(geometry!=NULL)
   {
-    m_TimeSlicedGeometry = NULL;
-    Modified();
+    timeGeometry->Initialize(geometry, 1);
   }
+  SetTimeGeometry(timeGeometry);
   return;
 }
 
+void mitk::BaseData::SetTimeGeometry(TimeGeometry* geometry)
+{
+  m_TimeGeometry = geometry;
+  this->Modified();
+}
+
 void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D)
 {
   SetGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()));
 }
 
+void mitk::BaseData::SetClonedTimeGeometry(const TimeGeometry* geometry)
+{
+  itk::LightObject::Pointer clonedGeometry = geometry->Clone();
+  SetTimeGeometry(dynamic_cast<TimeGeometry *>(clonedGeometry.GetPointer()));
+}
+
+
 void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time)
 {
-  if (m_TimeSlicedGeometry)
+  if (m_TimeGeometry)
   {
-    m_TimeSlicedGeometry->SetGeometry3D(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()), time);
+    m_TimeGeometry->SetTimeStepGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()),time);
   }
 }
 
 bool mitk::BaseData::IsEmptyTimeStep(unsigned int) const
 {
   return IsInitialized() == false;
 }
 
 bool mitk::BaseData::IsEmpty() const
 {
   if(IsInitialized() == false)
     return true;
-  const TimeSlicedGeometry* timeGeometry = const_cast<BaseData*>(this)->GetUpdatedTimeSlicedGeometry();
+  const TimeGeometry* timeGeometry = const_cast<BaseData*>(this)->GetUpdatedTimeGeometry();
   if(timeGeometry == NULL)
     return true;
-  unsigned int timeSteps = timeGeometry->GetTimeSteps();
+  unsigned int timeSteps = timeGeometry->GetNumberOfTimeSteps();
   for ( unsigned int t = 0 ; t < timeSteps ; ++t )
   {
     if(IsEmptyTimeStep(t) == false)
       return false;
   }
   return true;
 }
 
 itk::SmartPointer<mitk::BaseDataSource> mitk::BaseData::GetSource() const
 {
   return static_cast<mitk::BaseDataSource*>(Superclass::GetSource().GetPointer());
 }
 
 mitk::PropertyList::Pointer mitk::BaseData::GetPropertyList() const
 {
   return m_PropertyList;
 }
 
 
 mitk::BaseProperty::Pointer mitk::BaseData::GetProperty(const char *propertyKey) const
 {
   return m_PropertyList->GetProperty(propertyKey);
 }
 
 void mitk::BaseData::SetProperty(const char *propertyKey,
                                  BaseProperty* propertyValue)
 {
   m_PropertyList->SetProperty(propertyKey, propertyValue);
 }
 
 void mitk::BaseData::SetPropertyList(PropertyList *pList)
 {
   m_PropertyList = pList;
 }
 
 void mitk::BaseData::SetOrigin(const mitk::Point3D& origin)
 {
-  mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
+  TimeGeometry* timeGeom = GetTimeGeometry();
 
-  assert(timeSlicedGeometry!=NULL);
+  assert (timeGeom != NULL);
+  Geometry3D* geometry;
 
-  mitk::Geometry3D* geometry;
-
-  unsigned int steps = timeSlicedGeometry->GetTimeSteps();
-
-  for(unsigned int timestep = 0; timestep < steps; ++timestep)
+  TimeStepType steps = timeGeom->GetNumberOfTimeSteps();
+  for (TimeStepType timestep = 0; timestep < steps; ++timestep)
   {
     geometry = GetGeometry(timestep);
-    if(geometry != NULL)
+    if (geometry != NULL)
     {
       geometry->SetOrigin(origin);
     }
-    if(GetTimeSlicedGeometry()->GetEvenlyTimed())
-    {
-      GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry, steps);
-      break;
-    }
   }
 }
 
 unsigned long mitk::BaseData::GetMTime() const
 {
   unsigned long time = Superclass::GetMTime();
-  if(m_TimeSlicedGeometry.IsNotNull())
+  if(m_TimeGeometry.IsNotNull())
   {
-    if((time < m_TimeSlicedGeometry->GetMTime()))
+    if((time < m_TimeGeometry->GetMTime()))
     {
       Modified();
       return Superclass::GetMTime();
     }
-    //unsigned long geometryTime = m_TimeSlicedGeometry->GetMTime();
-    //if(time < geometryTime)
-    //{
-    //  return geometryTime;
-    //}
   }
   return time;
 }
 
 void mitk::BaseData::Graft(const itk::DataObject*)
 {
   itkExceptionMacro(<< "Graft not implemented for mitk::BaseData subclass " << this->GetNameOfClass())
 }
 
 void mitk::BaseData::CopyInformation( const itk::DataObject* data )
 {
   const Self* bd = dynamic_cast<const Self*>(data);
   if (bd != NULL)
   {
-    m_TimeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(bd->GetTimeSlicedGeometry()->Clone().GetPointer());
     m_PropertyList = bd->GetPropertyList()->Clone();
+    if (bd->GetTimeGeometry()!=NULL)
+    {
+      itk::LightObject::Pointer clon = bd->GetTimeGeometry()->Clone();
+      m_TimeGeometry = dynamic_cast<TimeGeometry *> (clon.GetPointer());
+    }
+
   }
   else
   {
     // pointer could not be cast back down; this can be the case if your filters input
     // and output objects differ in type; then you have to write your own GenerateOutputInformation method
     itkExceptionMacro(<< "mitk::BaseData::CopyInformation() cannot cast "
       << typeid(data).name() << " to "
       << typeid(Self*).name() );
   }
 
 }
 
 bool mitk::BaseData::IsInitialized() const
 {
   return m_Initialized;
 }
 
 void mitk::BaseData::Clear()
 {
   this->ClearData();
   this->InitializeEmpty();
 }
 
 void mitk::BaseData::ClearData()
 {
   if(m_Initialized)
   {
     ReleaseData();
     m_Initialized = false;
   }
 }
 
 void mitk::BaseData::ExecuteOperation(mitk::Operation* /*operation*/)
 {
   //empty by default. override if needed!
 }
 
 void mitk::BaseData::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << std::endl;
-  os << indent << " TimeSlicedGeometry: ";
-  if(GetTimeSlicedGeometry() == NULL)
+  os << indent << " TimeGeometry: ";
+  if(GetTimeGeometry() == NULL)
     os << "NULL" << std::endl;
   else
-    GetTimeSlicedGeometry()->Print(os, indent);
+    GetTimeGeometry()->Print(os, indent);
 }
-
diff --git a/Core/Code/DataManagement/mitkBaseData.h b/Core/Code/DataManagement/mitkBaseData.h
index 6b67252301..fb3306d35f 100644
--- a/Core/Code/DataManagement/mitkBaseData.h
+++ b/Core/Code/DataManagement/mitkBaseData.h
@@ -1,367 +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 "mitkTimeSlicedGeometry.h"
+#include "mitkTimeGeometry.h"
 #include <MitkExports.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)
 
-  //##Documentation
-  //## @brief Return the TimeSlicedGeometry 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::TimeSlicedGeometry* GetTimeSlicedGeometry() const
+  /**
+  * \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_TimeSlicedGeometry.GetPointer();
+    return m_TimeGeometry.GetPointer();
   }
 
-  //##Documentation
-  //## @brief Return the TimeSlicedGeometry 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::TimeSlicedGeometry* GetTimeSlicedGeometry()
+  /**
+  * \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_06} Please use GetTimeGeometry instead: For additional information see  @TimeGeometryGuide@
+  */
+  DEPRECATED(const mitk::TimeGeometry* GetTimeSlicedGeometry() const)
   {
-    return m_TimeSlicedGeometry.GetPointer();
+    return GetTimeGeometry();
   }
 
-  //##Documentation
-  //## @brief Return the Geometry3D of the data.
-  //##
-  //## The method does not simply return the value of the m_TimeSlicedGeometry
-  //## member. Before doing this, it makes sure that the TimeSlicedGeometry
-  //## is up-to-date (by setting the update extent to largest possible and
-  //## calling UpdateOutputInformation).
-  const mitk::TimeSlicedGeometry* GetUpdatedTimeSlicedGeometry();
+  /**
+  * @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();
+  }
 
-  //##Documentation
-  //## @brief Expands the TimeSlicedGeometry to a number of TimeSteps.
-  //##
-  //## The method expands the TimeSlicedGeometry 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.
+  /**
+  * @brief Return the Geometry3D 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.
+  *
+  * 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_06} Please use GetUpdatedTimeGeometry instead: For additional information see  @TimeGeometryGuide@
+  */
+  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 );
 
-  //##Documentation
-  //## @brief Return the Geometry3D of the data at time \a t.
-  //##
-  //## The method does not simply return
-  //## m_TimeSlicedGeometry->GetGeometry(t).
-  //## Before doing this, it makes sure that the Geometry3D is up-to-date
-  //## (by setting the update extent appropriately and calling
-  //## UpdateOutputInformation).
-  //##
-  //## @todo Appropriate setting of the update extent is missing.
+  /**
+  * \brief Return the Geometry3D 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
+  * (by setting the update extent appropriately and calling
+  * UpdateOutputInformation).
+  *
+  * @todo Appropriate setting of the update extent is missing.
+  */
   const mitk::Geometry3D* GetUpdatedGeometry(int t=0);
 
   //##Documentation
-  //## @brief Return the geometry, which is a TimeSlicedGeometry, of the data
+  //## @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::Geometry3D* GetGeometry(int t=0) const
   {
-    if(m_TimeSlicedGeometry.IsNull())
+    if(m_TimeGeometry.IsNull())
       return NULL;
-    return m_TimeSlicedGeometry->GetGeometry3D(t);
+    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
-  //## GetTimeSlicedGeometry()->UpdateInformation()
+  //## 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);
 
-  //##Documentation
-  //## @brief Set the Geometry3D of the data, which will be referenced (not copied!).
-  //## Assumes the data object has only 1 time step ( is a 3D object ).
-  //##
-  //## For convenience (and historic) reasons, it is also possible to set a complete
-  //## mitk::TimeSlicedGeometry*, which will be referenced (not copied!).
-  //##
-  //## @warning This method will normally be called internally by the sub-class of BaseData
-  //## during initialization.
-  //## \sa SetClonedGeometry
+  /**
+  * \brief Set the Geometry3D 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
+  * 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(Geometry3D* aGeometry3D);
 
-  //##Documentation
-  //## @brief Set a clone of the provided geometry as Geometry3D of the data.
-  //## Assumes the data object has only 1 time step ( is a 3D object )
-  //##
-  //## \sa SetGeometry
+  /**
+  * \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 Geometry3D* 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.
   //##
   //## \sa SetGeometry
   virtual void SetClonedGeometry(const Geometry3D* 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
   //##
   //## \warning Geometries contained in the Geometry3D will
   //## \em not be changed, e.g. in case the Geometry3D 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 Timeslicedgeometry
+  //## @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_TimeSlicedGeometry->GetTimeSteps();
+    return m_TimeGeometry->GetNumberOfTimeSteps();
   }
 
 
   //##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 TimeSlicedGeometry for a number of time steps.
-  //## The TimeSlicedGeometry is initialized empty and evenly timed.
+  //## \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 InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 );
+  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_06} Please use GetUpdatedTimeGeometry instead: For additional information see  @TimeGeometryGuide@
+  */
+  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::InitializeTimeSlicedGeometry() to ensure an existing valid geometry
+  //## 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;
 
-  TimeSlicedGeometry::Pointer m_TimeSlicedGeometry;
+  TimeGeometry::Pointer m_TimeGeometry;
 
 };
 
 } // namespace mitk
 
 
 #endif /* BASEDATA_H_HEADER_INCLUDED_C1EBB6FA */
diff --git a/Core/Code/DataManagement/mitkBaseDataTestImplementation.h b/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
index d14baaaa15..49789489ed 100644
--- a/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
+++ b/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
@@ -1,59 +1,59 @@
 /*===================================================================
 
 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 BASEDATAIMPLEMENTATION_H_HEADER_INCLUDED
 #define BASEDATAIMPLEMENTATION_H_HEADER_INCLUDED
 
 #include "mitkBaseData.h"
 
 namespace mitk {
 
   //##Documentation
   //## @brief Implementation of BaseData (for testing)
   //##
   //## As BaseData is an abstract class, we need an implementation for testing its methods
   //## @ingroup Data
 
   class BaseDataTestImplementation : public BaseData
   {
   public:
 
     mitkClassMacro(BaseDataTestImplementation, BaseData);
 
     itkNewMacro(Self);
     mitkCloneMacro(BaseDataTestImplementation);
 
-    virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps /* = 1 */ )
+    virtual void InitializeTimeGeometry( unsigned int timeSteps /* = 1 */ )
     {
-      Superclass::InitializeTimeSlicedGeometry(timeSteps);
+      Superclass::InitializeTimeGeometry(timeSteps);
     }
 
   protected:
 
     virtual bool VerifyRequestedRegion(){return false;};
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion(){return false;};
     virtual void SetRequestedRegionToLargestPossibleRegion(){};
     virtual void SetRequestedRegion( const itk::DataObject * /*data*/){};
 
     BaseDataTestImplementation(){};
     virtual ~BaseDataTestImplementation(){};
 
   };
 
 } // namespace
 
 #endif // BASEDATA_H_HEADER_INCLUDED
diff --git a/Core/Code/DataManagement/mitkDataStorage.cpp b/Core/Code/DataManagement/mitkDataStorage.cpp
index da7b70fd76..295164647c 100644
--- a/Core/Code/DataManagement/mitkDataStorage.cpp
+++ b/Core/Code/DataManagement/mitkDataStorage.cpp
@@ -1,536 +1,523 @@
 /*===================================================================
 
 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 "mitkDataStorage.h"
 
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkNodePredicateBase.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkGroupTagProperty.h"
 #include "itkMutexLockHolder.h"
 
 #include "itkCommand.h"
 
 
 mitk::DataStorage::DataStorage() : itk::Object()
 , m_BlockNodeModifiedEvents(false)
 {
 }
 
 
 mitk::DataStorage::~DataStorage()
 {
   ///// we can not call GetAll() in destructor, because it is implemented in a subclass
   //SetOfObjects::ConstPointer all = this->GetAll();
   //for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
   //  this->RemoveListeners(it->Value());
   //m_NodeModifiedObserverTags.clear();
   //m_NodeDeleteObserverTags.clear();
 }
 
 
 void mitk::DataStorage::Add(mitk::DataNode* node, mitk::DataNode* parent)
 {
   mitk::DataStorage::SetOfObjects::Pointer parents = mitk::DataStorage::SetOfObjects::New();
   parents->InsertElement(0, parent);
   this->Add(node, parents);
 }
 
 
 void mitk::DataStorage::Remove(const mitk::DataStorage::SetOfObjects* nodes)
 {
   if (nodes == NULL)
     return;
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); it++)
     this->Remove(it.Value());
 }
 
 
 mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::GetSubset(const NodePredicateBase* condition) const
 {
   mitk::DataStorage::SetOfObjects::ConstPointer result = this->FilterSetOfObjects(this->GetAll(), condition);
   return result;
 }
 
 
 mitk::DataNode* mitk::DataStorage::GetNamedNode(const char* name) const
 
 {
   if (name == NULL)
     return NULL;
 
   mitk::StringProperty::Pointer s(mitk::StringProperty::New(name));
   mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("name", s);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(p);
   if (rs->Size() >= 1)
     return rs->GetElement(0);
   else
     return NULL;
 }
 
 
 mitk::DataNode* mitk::DataStorage::GetNode(const NodePredicateBase* condition) const
 {
   if (condition == NULL)
     return NULL;
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(condition);
   if (rs->Size() >= 1)
     return rs->GetElement(0);
   else
     return NULL;
 }
 
 mitk::DataNode* mitk::DataStorage::GetNamedDerivedNode(const char* name, const mitk::DataNode* sourceNode, bool onlyDirectDerivations) const
 {
   if (name == NULL)
     return NULL;
 
   mitk::StringProperty::Pointer s(mitk::StringProperty::New(name));
   mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("name", s);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDerivations(sourceNode, p, onlyDirectDerivations);
   if (rs->Size() >= 1)
     return rs->GetElement(0);
   else
     return NULL;
 }
 
 
 void mitk::DataStorage::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   //Superclass::PrintSelf(os, indent);
   mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetAll();
   os << indent << "DataStorage " << this << " is managing " << all->Size() << " objects. List of objects:" << std::endl;
   for (mitk::DataStorage::SetOfObjects::ConstIterator allIt = all->Begin(); allIt != all->End(); allIt++)
   {
     std::string name;
     allIt.Value()->GetName(name);
     std::string datatype;
     if (allIt.Value()->GetData() != NULL)
       datatype = allIt.Value()->GetData()->GetNameOfClass();
     os << indent << " " << allIt.Value().GetPointer() << "<" << datatype << ">: " << name << std::endl;
     mitk::DataStorage::SetOfObjects::ConstPointer parents = this->GetSources(allIt.Value());
     if (parents->Size() > 0)
     {
       os << indent << "  Direct sources: ";
       for (mitk::DataStorage::SetOfObjects::ConstIterator parentIt = parents->Begin(); parentIt != parents->End(); parentIt++)
         os << parentIt.Value().GetPointer() << ", ";
       os << std::endl;
     }
     mitk::DataStorage::SetOfObjects::ConstPointer derivations = this->GetDerivations(allIt.Value());
     if (derivations->Size() > 0)
     {
       os << indent << "  Direct derivations: ";
       for (mitk::DataStorage::SetOfObjects::ConstIterator derivationIt = derivations->Begin(); derivationIt != derivations->End(); derivationIt++)
         os << derivationIt.Value().GetPointer() << ", ";
       os << std::endl;
     }
   }
   os << std::endl;
 }
 
 
 mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::FilterSetOfObjects(const SetOfObjects* set, const NodePredicateBase* condition) const
 {
   if (set == NULL)
     return NULL;
 
   mitk::DataStorage::SetOfObjects::Pointer result = mitk::DataStorage::SetOfObjects::New();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = set->Begin(); it != set->End(); it++)
     if (condition == NULL || condition->CheckNode(it.Value()) == true) //alway copy the set, otherwise the iterator in mitk::DataStorage::Remove() will crash
       result->InsertElement(result->Size(), it.Value());
 
   return mitk::DataStorage::SetOfObjects::ConstPointer(result);
 }
 
 
 const mitk::DataNode::GroupTagList mitk::DataStorage::GetGroupTags() const
 {
   DataNode::GroupTagList result;
   SetOfObjects::ConstPointer all = this->GetAll();
   if (all.IsNull())
     return result;
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = all->Begin(); nodeIt != all->End(); nodeIt++)  // for each node
   {
     mitk::PropertyList* pl = nodeIt.Value()->GetPropertyList();
     for (mitk::PropertyList::PropertyMap::const_iterator propIt = pl->GetMap()->begin(); propIt != pl->GetMap()->end(); propIt++)
       if (dynamic_cast<mitk::GroupTagProperty*>(propIt->second.GetPointer()) != NULL)
         result.insert(propIt->first);
   }
 
   return result;
 }
 
 
 void mitk::DataStorage::EmitAddNodeEvent(const mitk::DataNode* node)
 {
   AddNodeEvent.Send(node);
 }
 
 
 void mitk::DataStorage::EmitRemoveNodeEvent(const mitk::DataNode* node)
 {
   RemoveNodeEvent.Send(node);
 }
 
 void mitk::DataStorage::OnNodeInteractorChanged( itk::Object *caller, const itk::EventObject& )
 {
   const mitk::DataNode* _Node = dynamic_cast<const mitk::DataNode*>(caller);
   if(_Node)
   {
     InteractorChangedNodeEvent.Send( _Node );
   }
 }
 
 void mitk::DataStorage::OnNodeModifiedOrDeleted( const itk::Object *caller, const itk::EventObject &event )
 {
   if( m_BlockNodeModifiedEvents )
     return;
 
   const mitk::DataNode* _Node = dynamic_cast<const mitk::DataNode*>(caller);
   if(_Node)
   {
     const itk::ModifiedEvent* modEvent = dynamic_cast<const itk::ModifiedEvent*>(&event);
     if(modEvent)
       ChangedNodeEvent.Send(_Node);
     else
       DeleteNodeEvent.Send(_Node);
   }
 }
 
 
 void mitk::DataStorage::AddListeners( const mitk::DataNode* _Node )
 {
   itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne);
   // node must not be 0 and must not be yet registered
   mitk::DataNode* NonConstNode = const_cast<mitk::DataNode*>(_Node);
   if(_Node && m_NodeModifiedObserverTags
     .find(NonConstNode) == m_NodeModifiedObserverTags.end())
   {
     itk::MemberCommand<mitk::DataStorage>::Pointer nodeModifiedCommand =
       itk::MemberCommand<mitk::DataStorage>::New();
     nodeModifiedCommand->SetCallbackFunction(this
                               , &mitk::DataStorage::OnNodeModifiedOrDeleted);
     m_NodeModifiedObserverTags[NonConstNode]
       = NonConstNode->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
 
 
     itk::MemberCommand<mitk::DataStorage>::Pointer interactorChangedCommand = itk::MemberCommand<mitk::DataStorage>::New();
     interactorChangedCommand->SetCallbackFunction(this, &mitk::DataStorage::OnNodeInteractorChanged);
     m_NodeInteractorChangedObserverTags[NonConstNode] = NonConstNode->AddObserver( mitk::DataNode::InteractorChangedEvent(), interactorChangedCommand);
 
     // add itk delete listener on datastorage
     itk::MemberCommand<mitk::DataStorage>::Pointer deleteCommand =
       itk::MemberCommand<mitk::DataStorage>::New();
     deleteCommand->SetCallbackFunction(this, &mitk::DataStorage::OnNodeModifiedOrDeleted);
     // add observer
     m_NodeDeleteObserverTags[NonConstNode]
         = NonConstNode->AddObserver(itk::DeleteEvent(), deleteCommand);
   }
 }
 
 
 void mitk::DataStorage::RemoveListeners( const mitk::DataNode* _Node )
 {
   itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne) ;
   // node must not be 0 and must be registered
   mitk::DataNode* NonConstNode = const_cast<mitk::DataNode*>(_Node);
   if(_Node && m_NodeModifiedObserverTags
     .find(NonConstNode) != m_NodeModifiedObserverTags.end())
   {
     // const cast is bad! but sometimes it is necessary. removing an observer does not really
     // touch the internal state
     NonConstNode->RemoveObserver(m_NodeModifiedObserverTags
                                  .find(NonConstNode)->second);
     NonConstNode->RemoveObserver(m_NodeDeleteObserverTags
                                  .find(NonConstNode)->second);
     NonConstNode->RemoveObserver(m_NodeInteractorChangedObserverTags
       .find(NonConstNode)->second);
 
 
     m_NodeModifiedObserverTags.erase(NonConstNode);
     m_NodeDeleteObserverTags.erase(NonConstNode);
     m_NodeInteractorChangedObserverTags.erase(NonConstNode);
   }
 }
 
-mitk::TimeSlicedGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const SetOfObjects* input, const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
+mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const SetOfObjects* input, const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
 {
   if (input == NULL)
     throw std::invalid_argument("DataStorage: input is invalid");
 
   BoundingBox::PointsContainer::Pointer pointscontainer=BoundingBox::PointsContainer::New();
 
   BoundingBox::PointIdentifier pointid=0;
   Point3D point;
 
   Vector3D minSpacing;
   minSpacing.Fill(ScalarTypeNumericTraits::max());
 
   ScalarType stmin, stmax;
   stmin= ScalarTypeNumericTraits::NonpositiveMin();
   stmax= ScalarTypeNumericTraits::max();
 
   ScalarType minimalIntervallSize = stmax;
   ScalarType minimalTime = stmax;
   ScalarType maximalTime = 0;
 
   // Needed for check of zero bounding boxes
   mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
   BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
 
   for (SetOfObjects::ConstIterator it = input->Begin(); it != input->End(); ++it)
   {
     DataNode::Pointer node = it->Value();
     if((node.IsNotNull()) && (node->GetData() != NULL) &&
       (node->GetData()->IsEmpty()==false) &&
       node->IsOn(boolPropertyKey, renderer) &&
       node->IsOn(boolPropertyKey2, renderer)
       )
     {
-      const TimeSlicedGeometry* geometry = node->GetData()->GetUpdatedTimeSlicedGeometry();
-      if (geometry != NULL )
+      const TimeGeometry* timeGeometry = node->GetData()->GetUpdatedTimeGeometry();
+
+      if (timeGeometry != NULL )
       {
         // bounding box (only if non-zero)
-        BoundingBox::BoundsArrayType itkBounds = geometry->GetBoundingBox()->GetBounds();
+        BoundingBox::BoundsArrayType itkBounds = timeGeometry->GetBoundingBoxInWorld()->GetBounds();
         if (itkBounds == itkBoundsZero)
         {
           continue;
         }
 
         unsigned char i;
         for(i=0; i<8; ++i)
         {
-          point = geometry->GetCornerPoint(i);
+          point = timeGeometry->GetCornerPointInWorld(i);
           if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < large)
             pointscontainer->InsertElement( pointid++, point);
           else
           {
             itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. Node: " << node );
           }
         }
-        // spacing
         try
         {
-          AffineTransform3D::Pointer inverseTransform = AffineTransform3D::New();
-          geometry->GetIndexToWorldTransform()->GetInverse(inverseTransform);
-          vnl_vector< AffineTransform3D::MatrixType::ValueType > unitVector(3);
-          int axis;
-          for(axis = 0; axis < 3; ++axis)
-          {
-            unitVector.fill(0);
-            unitVector[axis] = 1.0;
-            ScalarType mmPerPixel = 1.0/(inverseTransform->GetMatrix()*unitVector).magnitude();
-            if(minSpacing[axis] > mmPerPixel)
-            {
-              minSpacing[axis] = mmPerPixel;
-            }
-          }
           // time bounds
           // iterate over all time steps
           // Attention: Objects with zero bounding box are not respected in time bound calculation
-          TimeBounds minTB = geometry->GetTimeBounds();
-          for (unsigned int i=0; i<geometry->GetTimeSteps(); i++)
+          for (TimeStepType i=0; i<timeGeometry->GetNumberOfTimeSteps(); i++)
           {
+            Vector3D spacing = node->GetData()->GetGeometry(i)->GetSpacing();
+            for (int axis = 0; axis < 3; ++ axis)
+            {
+              if (spacing[axis] < minSpacing[axis]) minSpacing[axis] = spacing[axis];
+            }
+
             const TimeBounds & curTimeBounds = node->GetData()->GetGeometry(i)->GetTimeBounds();
+            TimePointType currentTimePoint = node->GetData()->GetTimeGeometry()->TimeStepToTimePoint(i);
             // get the minimal time of all objects in the DataStorage
             if ((curTimeBounds[0]<minimalTime)&&(curTimeBounds[0]>stmin))
             {
               minimalTime=curTimeBounds[0];
             }
             // get the maximal time of all objects in the DataStorage
             if ((curTimeBounds[1]>maximalTime)&&(curTimeBounds[1]<stmax))
             {
               maximalTime = curTimeBounds[1];
             }
             // get the minimal TimeBound of all time steps of the current DataNode
-            if (curTimeBounds[1]-curTimeBounds[0]<minTB[1]-minTB[0])
+            if (curTimeBounds[1]-curTimeBounds[0]<minimalIntervallSize)
             {
-              minTB = curTimeBounds;
+              minimalIntervallSize = curTimeBounds[1]-curTimeBounds[0];
             }
           }
-          // get the minimal interval size of all time steps of all objects of the DataStorage
-          if (minTB[1]-minTB[0]<minimalIntervallSize)
-          {
-            minimalIntervallSize = minTB[1]-minTB[0];
-          }
         }
         catch(itk::ExceptionObject e)
         {
           MITK_ERROR << e << std::endl;
         }
       }
     }
   }
 
   BoundingBox::Pointer result = BoundingBox::New();
   result->SetPoints(pointscontainer);
   result->ComputeBoundingBox();
 
   // minimal time bounds of a single time step for all geometries
   TimeBounds minTimeBounds;
   minTimeBounds[0] = 0;
   minTimeBounds[1] = 1;
   // compute the number of time steps
   unsigned int numberOfTimeSteps = 1;
   if (maximalTime!=0) // make sure that there is at least one time sliced geometry in the data storage
   {
     minTimeBounds[0] = minimalTime;
     minTimeBounds[1] = minimalTime + minimalIntervallSize;
     numberOfTimeSteps = static_cast<unsigned int>((maximalTime-minimalTime)/minimalIntervallSize);
   }
 
-  TimeSlicedGeometry::Pointer timeSlicedGeometry = NULL;
+  TimeGeometry::Pointer timeGeometry = NULL;
   if ( result->GetPoints()->Size()>0 )
   {
     // Initialize a geometry of a single time step
     Geometry3D::Pointer geometry = Geometry3D::New();
     geometry->Initialize();
     // correct bounding-box (is now in mm, should be in index-coordinates)
     // according to spacing
     BoundingBox::BoundsArrayType bounds = result->GetBounds();
     int i;
     for(i = 0; i < 6; ++i)
     {
       bounds[i] /= minSpacing[i/2];
     }
     geometry->SetBounds(bounds);
     geometry->SetSpacing(minSpacing);
     geometry->SetTimeBounds(minTimeBounds);
     // Initialize the time sliced geometry
-    timeSlicedGeometry = TimeSlicedGeometry::New();
-    timeSlicedGeometry->InitializeEvenlyTimed(geometry,numberOfTimeSteps);
+    timeGeometry = ProportionalTimeGeometry::New();
+    dynamic_cast<ProportionalTimeGeometry*>(timeGeometry.GetPointer())->Initialize(geometry,numberOfTimeSteps);
   }
-  return timeSlicedGeometry;
+  return timeGeometry;
 }
 
-mitk::TimeSlicedGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
+mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
 {
   return this->ComputeBoundingGeometry3D(this->GetAll(), boolPropertyKey, renderer, boolPropertyKey2);
 }
 
-mitk::TimeSlicedGeometry::Pointer mitk::DataStorage::ComputeVisibleBoundingGeometry3D( mitk::BaseRenderer* renderer, const char* boolPropertyKey )
+mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeVisibleBoundingGeometry3D( mitk::BaseRenderer* renderer, const char* boolPropertyKey )
 {
   return ComputeBoundingGeometry3D( "visible", renderer, boolPropertyKey );
 }
 
 
 mitk::BoundingBox::Pointer mitk::DataStorage::ComputeBoundingBox( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
 {
   BoundingBox::PointsContainer::Pointer pointscontainer=BoundingBox::PointsContainer::New();
 
   BoundingBox::PointIdentifier pointid=0;
   Point3D point;
 
   // Needed for check of zero bounding boxes
   mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
   BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
 
   SetOfObjects::ConstPointer all = this->GetAll();
   for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
   {
     DataNode::Pointer node = it->Value();
     if((node.IsNotNull()) && (node->GetData() != NULL) &&
       (node->GetData()->IsEmpty()==false) &&
       node->IsOn(boolPropertyKey, renderer) &&
       node->IsOn(boolPropertyKey2, renderer)
       )
     {
-      const Geometry3D* geometry = node->GetData()->GetUpdatedTimeSlicedGeometry();
+      const TimeGeometry* geometry = node->GetData()->GetUpdatedTimeGeometry();
       if (geometry != NULL )
       {
         // bounding box (only if non-zero)
-        BoundingBox::BoundsArrayType itkBounds = geometry->GetBoundingBox()->GetBounds();
+        BoundingBox::BoundsArrayType itkBounds = geometry->GetBoundingBoxInWorld()->GetBounds();
         if (itkBounds == itkBoundsZero)
         {
           continue;
         }
 
         unsigned char i;
         for(i=0; i<8; ++i)
         {
-          point = geometry->GetCornerPoint(i);
+          point = geometry->GetCornerPointInWorld(i);
           if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < large)
             pointscontainer->InsertElement( pointid++, point);
           else
           {
             itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. Node: " << node );
           }
         }
       }
     }
 
   }
 
   BoundingBox::Pointer result = BoundingBox::New();
   result->SetPoints(pointscontainer);
   result->ComputeBoundingBox();
 
   return result;
 }
 
 
 mitk::TimeBounds mitk::DataStorage::ComputeTimeBounds( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
 {
   TimeBounds timeBounds;
 
   ScalarType stmin, stmax, cur;
 
   stmin= ScalarTypeNumericTraits::NonpositiveMin();
   stmax= ScalarTypeNumericTraits::max();
 
   timeBounds[0]=stmax; timeBounds[1]=stmin;
 
   SetOfObjects::ConstPointer all = this->GetAll();
   for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
   {
     DataNode::Pointer node = it->Value();
     if((node.IsNotNull()) && (node->GetData() != NULL) &&
       (node->GetData()->IsEmpty()==false) &&
       node->IsOn(boolPropertyKey, renderer) &&
       node->IsOn(boolPropertyKey2, renderer)
       )
     {
-      const Geometry3D* geometry = node->GetData()->GetUpdatedTimeSlicedGeometry();
+      const TimeGeometry* geometry = node->GetData()->GetUpdatedTimeGeometry();
       if (geometry != NULL )
       {
         const TimeBounds & curTimeBounds = geometry->GetTimeBounds();
         cur=curTimeBounds[0];
         //is it after -infinity, but before everything else that we found until now?
         if((cur > stmin) && (cur < timeBounds[0]))
           timeBounds[0] = cur;
 
         cur=curTimeBounds[1];
         //is it before infinity, but after everything else that we found until now?
         if((cur < stmax) && (cur > timeBounds[1]))
           timeBounds[1] = cur;
       }
     }
   }
   if(!(timeBounds[0] < stmax))
   {
     timeBounds[0] = stmin;
     timeBounds[1] = stmax;
   }
   return timeBounds;
 }
 
 void mitk::DataStorage::BlockNodeModifiedEvents( bool block )
 {
   m_BlockNodeModifiedEvents = block;
 }
diff --git a/Core/Code/DataManagement/mitkDataStorage.h b/Core/Code/DataManagement/mitkDataStorage.h
index 6a6a114fa7..4723eaefc4 100644
--- a/Core/Code/DataManagement/mitkDataStorage.h
+++ b/Core/Code/DataManagement/mitkDataStorage.h
@@ -1,414 +1,414 @@
 /*===================================================================
 
 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 MITKDATASTORAGE_H_HEADER_INCLUDED_
 #define MITKDATASTORAGE_H_HEADER_INCLUDED_
 
 #include "itkObject.h"
 #include <MitkExports.h>
 #include "mitkMessage.h"
 #include "itkVectorContainer.h"
 #include "mitkDataNode.h"
 #include "mitkGeometry3D.h"
 #include "itkSimpleFastMutexLock.h"
 #include <map>
 
 namespace mitk {
 
   class NodePredicateBase;
   class DataNode;
   class BaseRenderer;
 
   //##Documentation
   //## @brief Data management class that handles 'was created by' relations
   //##
   //## The DataStorage provides data storage and management functionality.
   //## It handles a 'was created by' relation by associating each data object with a
   //## set of source objects, that this object was created from.
   //## Thus, nodes are stored in a noncyclical directed graph data structure.
   //## If a new node is added to the DataStorage, AddNodeEvent is emitted.
   //## If a node is removed, RemoveNodeEvent is emitted.
   //##
   //##
   //## \ingroup DataStorage
   class MITK_CORE_EXPORT DataStorage : public itk::Object
   {
   public:
     mitkClassMacro(DataStorage, itk::Object);
 
     //##Documentation
     //## @brief A Container of objects that is used as a result set of GetSubset() query operations (Set of SmartPointers to DataNodes).
     typedef itk::VectorContainer<unsigned int, mitk::DataNode::Pointer> SetOfObjects;
 
     //##Documentation
     //## @brief Adds a DataNode containing a data object to its internal storage
     //##
     //## This Method adds a new data object to the DataStorage. The new object is
     //## passed in the first parameter. The second parameter is a set
     //## of source objects, that were used to create this object. The new object will have
     //## a 'was created from' relation to its source objects.
     //## the addition of a new object will fire the notification mechanism.
     //## If the node parameter is NULL or if the DataNode has already been added,
     //## an exception will be thrown.
     virtual void Add(mitk::DataNode* node, const mitk::DataStorage::SetOfObjects* parents = NULL) = 0;
 
     //##Documentation
     //## @brief Convenience method to add a node that has one parent
     //##
     void Add(mitk::DataNode* node, mitk::DataNode* parent);
 
     //##Documentation
     //## @brief Removes node from the DataStorage
     //##
     virtual void Remove(const mitk::DataNode* node) = 0;
 
     //##Documentation
     //## @brief Checks if a node exists in the DataStorage
     //##
     virtual bool Exists(const mitk::DataNode* node) const = 0;
 
     //##Documentation
     //## @brief Removes a set of nodes from the DataStorage
     //##
     void Remove(const mitk::DataStorage::SetOfObjects* nodes);
 
     //##Documentation
     //## @brief returns a set of data objects that meet the given condition(s)
     //##
     //## GetSubset returns a set of objects  with a specific data type that meet the condition(s)
     //## specified in the condition parameter. Conditions can be
     //##  - data type of the data object
     //##  - is source object of specific object (e.g. all source objects of node x)
     //##  - has property with specific value (e.g. OrganType is Liver)
     //##  - negation of any condition
     //##  - conjunction of a set of conditions
     //##  - disjunction of a set of conditions
     //## Conditions are implemented as predicates using the Composite Design Pattern
     //## (see definition of NodePredicateBase for details).
     //## The method returns a set of SmartPointers to the DataNodes that fulfill the
     //## conditions. A set of all objects can be retrieved with the GetAll() method;
     SetOfObjects::ConstPointer GetSubset(const NodePredicateBase* condition) const;
 
     //##Documentation
     //## @brief returns a set of source objects for a given node that meet the given condition(s).
     //##
     virtual SetOfObjects::ConstPointer GetSources(const mitk::DataNode* node, const NodePredicateBase* condition = NULL, bool onlyDirectSources = true) const = 0;
 
     //##Documentation
     //## @brief returns a set of derived objects for a given node.
     //##
     //## GetDerivations() returns a set of objects that are derived from the DataNode node.
     //## This means, that node was used to create the returned objects. If the parameter
     //## onlyDirectDerivations is set to true (default value), only objects that directly have
     //## node as one of their source objects will be returned. Otherwise, objects that are
     //## derived from derivations of node are returned too.
     //## The derived objects can be filtered with a predicate object as described in the GetSubset()
     //## method by providing a predicate as the condition parameter.
     virtual SetOfObjects::ConstPointer GetDerivations(const mitk::DataNode* node, const NodePredicateBase* condition = NULL, bool onlyDirectDerivations = true) const = 0;
 
     //##Documentation
     //## @brief returns a set of all data objects that are stored in the data storage
     //##
     virtual SetOfObjects::ConstPointer GetAll() const = 0;
 
     //##Documentation
     //## @brief Convenience method to get the first node that matches the predicate condition
     //##
     mitk::DataNode* GetNode(const NodePredicateBase* condition = NULL) const;
 
 
     //##Documentation
     //## @brief Convenience method to get the first node with a given name
     //##
     mitk::DataNode* GetNamedNode(const char* name) const;
 
     //##Documentation
     //## @brief Convenience method to get the first node with a given name
     //##
     mitk::DataNode* GetNamedNode(const std::string name) const
     {
       return this->GetNamedNode(name.c_str());
     }
 
     //##Documentation
     //## @brief Convenience method to get the first node with a given name that is derived from sourceNode
     //##
     mitk::DataNode* GetNamedDerivedNode(const char* name, const mitk::DataNode* sourceNode, bool onlyDirectDerivations = true) const;
 
     //##Documentation
     //## @brief Convenience method to get the first data object of a given data type with a given name
     //##
     template <class DataType>
     DataType* GetNamedObject(const char* name) const
     {
       if (name == NULL)
         return NULL;
       mitk::DataNode* n = this->GetNamedNode(name);
       if (n == NULL)
         return NULL;
       else
         return dynamic_cast<DataType*>(n->GetData());
     }
     //##Documentation
     //## @brief Convenience method to get the first data object of a given data type with a given name
     //##
     template <class DataType>
     DataType* GetNamedObject(const std::string name) const
     {
       return this->GetNamedObject<DataType>(name.c_str());
     }
 
     //##Documentation
     //## @brief Convenience method to get the first data object of a given data type with a given name that is derived from a specific node
     //##
     template <class DataType>
     DataType* GetNamedDerivedObject(const char* name, const mitk::DataNode* sourceNode, bool onlyDirectDerivations = true) const
     {
       if (name == NULL)
         return NULL;
       mitk::DataNode* n = this->GetNamedDerivedNode(name, sourceNode, onlyDirectDerivations);
       if (n == NULL)
         return NULL;
       else
         return dynamic_cast<DataType*>(n->GetData());
     }
 
     //##Documentation
     //## @brief Returns a list of used grouptags
     //##
     const DataNode::GroupTagList GetGroupTags() const;
 
     /*ITK Mutex */
     mutable itk::SimpleFastMutexLock m_MutexOne;
 
     /* Public Events */
     typedef Message1<const mitk::DataNode*> DataStorageEvent;
     //##Documentation
     //## @brief AddEvent is emitted whenever a new node has been added to the DataStorage.
     //##
     //## Observers should register to this event by calling myDataStorage->AddNodeEvent.AddListener(myObject, MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called every time a new node has been added to the DataStorage.
     //## Observers should unregister by calling myDataStorage->AddNodeEvent.RemoveListener(myObject, MyObject::MyMethod).
     //## Note: AddEvents are _not_ emitted if a node is added to DataStorage by adding it to the the underlying DataTree!
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef for
     // a Message1 object which is thread safe
     DataStorageEvent AddNodeEvent;
 
     //##Documentation
     //## @brief RemoveEvent is emitted directly before a node is removed from the DataStorage.
     //##
     //## Observers should register to this event by calling myDataStorage->RemoveNodeEvent.AddListener(myObject, MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called every time a new node has been added to the DataStorage.
     //## Observers should unregister by calling myDataStorage->RemoveNodeEvent.RemoveListener(myObject, MyObject::MyMethod).
     //## Note: RemoveEvents are also emitted if a node was removed from the DataStorage by deleting it from the underlying DataTree
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef for
     // a Message1 object which is thread safe
     DataStorageEvent RemoveNodeEvent;
 
     //##Documentation
     //## @brief ChangedEvent is emitted directly after a node was changed.
     //##
     //## Observers should register to this event by calling myDataStorage->ChangedNodeEvent.AddListener(myObject, MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called every time a new node has been changed.
     //## Observers should unregister by calling myDataStorage->ChangedNodeEvent.RemoveListener(myObject, MyObject::MyMethod).
     //## Internally the DataStorage listens to itk::ModifiedEvents on the nodes and forwards them
     //## to the listeners of this event.
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef for
     // a Message1 object which is thread safe
     DataStorageEvent ChangedNodeEvent;
 
     //##Documentation
     //## @brief DeleteNodeEvent is emitted directly before a node is deleted.
     //##
     //## Observers should register to this event by calling myDataStorage->DeleteNodeEvent.AddListener(myObject, MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called when a node is deleted.
     //## Observers should unregister by calling myDataStorage->DeleteNodeEvent.RemoveListener(myObject, MyObject::MyMethod).
     //## Internally the DataStorage listens to itk::DeleteEvents on the nodes and forwards them
     //## to the listeners of this event.
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef for
     // a Message1 object which is thread safe
     DataStorageEvent DeleteNodeEvent;
 
     DataStorageEvent InteractorChangedNodeEvent;
 
 
     //##Documentation
     //## @brief Compute the axis-parallel bounding geometry of the input objects
     //##
     //## Throws std::invalid_argument exception if input is NULL
     //## @param input set of objects of the DataStorage to be included in the bounding geometry
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
-    mitk::TimeSlicedGeometry::Pointer ComputeBoundingGeometry3D( const SetOfObjects* input, const char* boolPropertyKey = NULL, mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey2 = NULL);
+    mitk::TimeGeometry::Pointer ComputeBoundingGeometry3D( const SetOfObjects* input, const char* boolPropertyKey = NULL, mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey2 = NULL);
 
     //##Documentation
     //## @brief Compute the axis-parallel bounding geometry of the data tree
     //## (bounding box, minimal spacing of the considered nodes, live-span)
     //##
     //## it -> an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
-    mitk::TimeSlicedGeometry::Pointer ComputeBoundingGeometry3D( const char* boolPropertyKey = NULL, mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey2 = NULL);
+    mitk::TimeGeometry::Pointer ComputeBoundingGeometry3D( const char* boolPropertyKey = NULL, mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey2 = NULL);
 
     //##Documentation
     //## @brief Compute the axis-parallel bounding geometry of all visible parts of the
     //## data tree bounding box, minimal spacing of the considered nodes, live-span)
     //##
     //## Simply calls ComputeBoundingGeometry3D(it, "visible", renderer, boolPropertyKey).
     //## it -> an iterator of a data tree structure
     //## @param renderer the reference to the renderer
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
-    mitk::TimeSlicedGeometry::Pointer ComputeVisibleBoundingGeometry3D( mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey = NULL);
+    mitk::TimeGeometry::Pointer ComputeVisibleBoundingGeometry3D( mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey = NULL);
 
     //##Documentation
     //## @brief Compute the bounding box of data tree structure
     //## it -> an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
      //## and is set to @a false, the node is ignored for the bounding-box calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
     mitk::BoundingBox::Pointer ComputeBoundingBox( const char* boolPropertyKey = NULL, mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey2 = NULL);
 
     //##Documentation
     //## \brief Compute the bounding box of all visible parts of the data tree structure, for general
     //## rendering or renderer specific visibility property checking
     //##
     //## Simply calls ComputeBoundingBox(it, "visible", renderer, boolPropertyKey).
     //## it -> an iterator of a data tree structure
     //## @param renderer the reference to the renderer
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     mitk::BoundingBox::Pointer ComputeVisibleBoundingBox( mitk::BaseRenderer* renderer = NULL, const char* boolPropertyKey = NULL)
     {
       return ComputeBoundingBox( "visible", renderer, boolPropertyKey);
     }
 
     //##Documentation
     //## @brief Compute the time-bounds of the contents of a data tree structure
     //##
     //## The methods returns only [-infinity, +infinity], if all data-objects have an infinite live-span. Otherwise,
     //## all data-objects with infinite live-span are ignored.
     //## it -> an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the time-bounds calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
     mitk::TimeBounds ComputeTimeBounds( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2);
 
     //##Documentation
     //## @brief Compute the time-bounds of all visible parts of the data tree structure, for general
      //## rendering or renderer specific visibility property checking
     //##
     //## The methods returns only [-infinity, +infinity], if all data-objects have an infinite live-span. Otherwise,
     //## all data-objects with infinite live-span are ignored.
     //## Simply calls ComputeTimeBounds(it, "visible", renderer, boolPropertyKey).
     //## @param it an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the time-bounds calculation.
     //## @param renderer see @a boolPropertyKey
     mitk::TimeBounds ComputeTimeBounds( mitk::BaseRenderer* renderer, const char* boolPropertyKey)
     {
       return ComputeTimeBounds( "visible", renderer, boolPropertyKey);
     }
 
     //##Documentation
     //## @brief Defines whether or not NodeChangedEvent is invoked .
     //##
     //## This method can be used to set m_BlockNodeModifiedEvents.
     //##
     //## If this flag is true, NodeChangedEvent is not invoked when a
     //## DataNode is modified. This might be undesired when setting
     //## many properties on a datanode and you do not want anyone to
     //## react.
     void BlockNodeModifiedEvents( bool block );
 
   protected:
     //##Documentation
     //## @brief  EmitAddNodeEvent emits the AddNodeEvent
     //##
     //## This method should be called by subclasses to emit the AddNodeEvent
     void EmitAddNodeEvent(const mitk::DataNode* node);
 
     //##Documentation
     //## @brief  EmitRemoveNodeEvent emits the RemoveNodeEvent
     //##
     //## This method should be called by subclasses to emit the RemoveNodeEvent
     void EmitRemoveNodeEvent(const mitk::DataNode* node);
 
     void OnNodeInteractorChanged( itk::Object *caller, const itk::EventObject &event );
 
 
     //##Documentation
     //## @brief  OnNodeModified listens to modified events of DataNodes.
     //##
     //## The node is hidden behind the caller parameter, which has to be casted first.
     //## If the cast succeeds the ChangedNodeEvent is emitted with this node.
     void OnNodeModifiedOrDeleted( const itk::Object *caller, const itk::EventObject &event );
 
     //##Documentation
     //## @brief  Adds a Modified-Listener to the given Node.
     void AddListeners(const mitk::DataNode* _Node);
 
     //##Documentation
     //## @brief  Removes a Modified-Listener from the given Node.
     void RemoveListeners(const mitk::DataNode* _Node);
 
 
 
     //##Documentation
     //## @brief  Saves Modified-Observer Tags for each node in order to remove the event listeners again.
     std::map<const mitk::DataNode*, unsigned long> m_NodeModifiedObserverTags;
 
     std::map<const mitk::DataNode*, unsigned long> m_NodeInteractorChangedObserverTags;
 
 
     //##Documentation
     //## @brief  Saves Delete-Observer Tags for each node in order to remove the event listeners again.
     std::map<const mitk::DataNode*, unsigned long> m_NodeDeleteObserverTags;
 
     //##Documentation
     //## @brief If this class changes nodes itself, set this to TRUE in order
     //## to suppress NodeChangedEvent to be emitted.
     bool m_BlockNodeModifiedEvents;
 
     //##Documentation
     //## @brief Standard Constructor for ::New() instantiation
     DataStorage();
     //##Documentation
     //## @brief Standard Destructor
     virtual ~DataStorage();
 
     //##Documentation
     //## @brief Filters a SetOfObjects by the condition. If no condition is provided, the original set is returned
     SetOfObjects::ConstPointer FilterSetOfObjects(const SetOfObjects* set, const NodePredicateBase* condition) const;
 
     //##Documentation
     //## @brief Prints the contents of the DataStorage to os. Do not call directly, call ->Print() instead
     virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
   };
 } // namespace mitk
 
 #endif /* MITKDATASTORAGE_H_HEADER_INCLUDED_ */
diff --git a/Core/Code/DataManagement/mitkDisplayGeometry.cpp b/Core/Code/DataManagement/mitkDisplayGeometry.cpp
index c3ba22a36a..39fac88de3 100644
--- a/Core/Code/DataManagement/mitkDisplayGeometry.cpp
+++ b/Core/Code/DataManagement/mitkDisplayGeometry.cpp
@@ -1,635 +1,637 @@
 /*===================================================================
 
 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 "mitkDisplayGeometry.h"
 
 itk::LightObject::Pointer mitk::DisplayGeometry::InternalClone() const
 {
-  itkExceptionMacro(<<"calling mitk::DisplayGeometry::Clone does not make much sense.");
+//  itkExceptionMacro(<<"calling mitk::DisplayGeometry::Clone does not make much sense.");
+  DisplayGeometry* returnValue = const_cast<DisplayGeometry *>(this);
+  return returnValue;
 }
 
 bool mitk::DisplayGeometry::IsValid() const
 {
   return m_Valid && m_WorldGeometry.IsNotNull() && m_WorldGeometry->IsValid();
 }
 
 unsigned long mitk::DisplayGeometry::GetMTime() const
 {
   if((m_WorldGeometry.IsNotNull()) && (Geometry2D::GetMTime() < m_WorldGeometry->GetMTime()))
   {
     Modified();
   }
   return Geometry2D::GetMTime();
 }
 
 const mitk::TimeBounds& mitk::DisplayGeometry::GetTimeBounds() const
 {
   if(m_WorldGeometry.IsNull())
   {
     return m_TimeBounds;
   }
 
   return m_WorldGeometry->GetTimeBounds();
 }
 
 
 
 
 
 
 // size definition methods
 
 void mitk::DisplayGeometry::SetWorldGeometry(const Geometry2D* aWorldGeometry)
 {
   m_WorldGeometry = aWorldGeometry;
 
   Modified();
 }
 
 bool mitk::DisplayGeometry::SetOriginInMM(const Vector2D& origin_mm)
 {
   m_OriginInMM = origin_mm;
   WorldToDisplay(m_OriginInMM, m_OriginInDisplayUnits);
 
   Modified();
 
   return !this->RefitVisibleRect();
 }
 
 mitk::Vector2D mitk::DisplayGeometry::GetOriginInMM() const
 {
   return m_OriginInMM;
 }
 
 mitk::Vector2D mitk::DisplayGeometry::GetOriginInDisplayUnits() const
 {
   return m_OriginInDisplayUnits;
 }
 
 void mitk::DisplayGeometry::SetSizeInDisplayUnits(unsigned int width, unsigned int height, bool keepDisplayedRegion)
 {
   Vector2D oldSizeInMM( m_SizeInMM );
   Point2D oldCenterInMM;
   if(keepDisplayedRegion)
   {
     Point2D centerInDisplayUnits;
     centerInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
     centerInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;
     DisplayToWorld(centerInDisplayUnits, oldCenterInMM);
   }
 
   m_SizeInDisplayUnits[0]=width;
   m_SizeInDisplayUnits[1]=height;
 
   if(m_SizeInDisplayUnits[0] <= 0)
     m_SizeInDisplayUnits[0] = 1;
   if(m_SizeInDisplayUnits[1] <= 0)
     m_SizeInDisplayUnits[1] = 1;
 
   DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);
 
   if(keepDisplayedRegion)
   {
     Point2D positionOfOldCenterInCurrentDisplayUnits;
     WorldToDisplay(oldCenterInMM, positionOfOldCenterInCurrentDisplayUnits);
 
     Point2D currentNewCenterInDisplayUnits;
     currentNewCenterInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
     currentNewCenterInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;
 
     Vector2D shift;
     shift=positionOfOldCenterInCurrentDisplayUnits.GetVectorFromOrigin()-currentNewCenterInDisplayUnits;
 
     MoveBy(shift);
     Zoom(m_SizeInMM.GetNorm()/oldSizeInMM.GetNorm(), currentNewCenterInDisplayUnits);
   }
 
   Modified();
 }
 
 mitk::Vector2D mitk::DisplayGeometry::GetSizeInDisplayUnits() const
 {
   return m_SizeInDisplayUnits;
 }
 
 mitk::Vector2D mitk::DisplayGeometry::GetSizeInMM() const
 {
   return m_SizeInMM;
 }
 
 unsigned int mitk::DisplayGeometry::GetDisplayWidth() const
 {
   assert(m_SizeInDisplayUnits[0] >= 0);
   return (unsigned int)m_SizeInDisplayUnits[0];
 }
 
 unsigned int mitk::DisplayGeometry::GetDisplayHeight() const
 {
   assert(m_SizeInDisplayUnits[1] >= 0);
   return (unsigned int)m_SizeInDisplayUnits[1];
 }
 
 
 
 
 
 // zooming, panning, restriction of both
 
 void mitk::DisplayGeometry::SetConstrainZoomingAndPanning(bool constrain)
 {
   m_ConstrainZoomingAndPanning = constrain;
   if (m_ConstrainZoomingAndPanning)
   {
     this->RefitVisibleRect();
   }
 }
 
 bool mitk::DisplayGeometry::GetConstrainZommingAndPanning() const
 {
   return m_ConstrainZoomingAndPanning;
 }
 
 bool mitk::DisplayGeometry::SetScaleFactor(ScalarType mmPerDisplayUnit)
 {
   if(mmPerDisplayUnit<0.0001)
   {
     mmPerDisplayUnit=0.0001;
   }
 
   m_ScaleFactorMMPerDisplayUnit = mmPerDisplayUnit;
   assert(m_ScaleFactorMMPerDisplayUnit < ScalarTypeNumericTraits::infinity());
 
   DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);
 
   return !this->RefitVisibleRect();
 }
 
 mitk::ScalarType mitk::DisplayGeometry::GetScaleFactorMMPerDisplayUnit() const
 {
   return m_ScaleFactorMMPerDisplayUnit;
 }
 
 // Zooms with a factor (1.0=identity) around the specified center in display units
 bool mitk::DisplayGeometry::Zoom(ScalarType factor, const Point2D& centerInDisplayUnits)
 {
   assert(factor > 0);
 
   if ( SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor) )
   {
     return SetOriginInMM(m_OriginInMM-centerInDisplayUnits.GetVectorFromOrigin()*(1-factor)*m_ScaleFactorMMPerDisplayUnit);
   }
   else
   {
     return false;
   }
 }
 
 
 // Zooms with a factor (1.0=identity) around the specified center, but tries (if its within view contraints) to match the center in display units with the center in world coordinates.
 bool mitk::DisplayGeometry::ZoomWithFixedWorldCoordinates(ScalarType factor, const Point2D& focusDisplayUnits, const Point2D& focusUnitsInMM )
 {
   assert(factor > 0);
 
   SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor);
   SetOriginInMM(focusUnitsInMM.GetVectorFromOrigin()-focusDisplayUnits.GetVectorFromOrigin()*m_ScaleFactorMMPerDisplayUnit);
   return true;
 }
 
 
 bool mitk::DisplayGeometry::MoveBy(const Vector2D& shiftInDisplayUnits)
 {
   SetOriginInMM(m_OriginInMM+shiftInDisplayUnits*m_ScaleFactorMMPerDisplayUnit);
 
   Modified();
 
   return !this->RefitVisibleRect();
 }
 
 void mitk::DisplayGeometry::Fit()
 {
   if((m_WorldGeometry.IsNull()) || (m_WorldGeometry->IsValid() == false)) return;
 
   /// \FIXME: try to remove all the casts
   int width=(int)m_SizeInDisplayUnits[0];
   int height=(int)m_SizeInDisplayUnits[1];
 
   ScalarType w = width;
   ScalarType h = height;
 
   const ScalarType& widthInMM = m_WorldGeometry->GetParametricExtentInMM(0);
   const ScalarType& heightInMM = m_WorldGeometry->GetParametricExtentInMM(1);
   ScalarType aspRatio=((ScalarType)widthInMM)/heightInMM;
 
   ScalarType x = (ScalarType)w/widthInMM;
   ScalarType y = (ScalarType)h/heightInMM;
 
   if (x > y)
   {
     w = (int) (aspRatio*h);
   }
   else
   {
     h = (int) (w/aspRatio);
   }
 
   if(w>0)
   {
     SetScaleFactor(widthInMM/w);
   }
 
   Vector2D origin_display;
   origin_display[0]=-(width-w)/2.0;
   origin_display[1]=-(height-h)/2.0;
   SetOriginInMM(origin_display*m_ScaleFactorMMPerDisplayUnit);
 
   this->RefitVisibleRect();
 
   Modified();
 }
 
 
 
 
 
 // conversion methods
 
 void mitk::DisplayGeometry::DisplayToWorld(const Point2D &pt_display, Point2D &pt_mm) const
 {
   pt_mm[0]=m_ScaleFactorMMPerDisplayUnit*pt_display[0]+m_OriginInMM[0];
   pt_mm[1]=m_ScaleFactorMMPerDisplayUnit*pt_display[1]+m_OriginInMM[1];
 }
 
 void mitk::DisplayGeometry::WorldToDisplay(const Point2D &pt_mm, Point2D &pt_display) const
 {
   pt_display[0]=(pt_mm[0]-m_OriginInMM[0])*(1.0/m_ScaleFactorMMPerDisplayUnit);
   pt_display[1]=(pt_mm[1]-m_OriginInMM[1])*(1.0/m_ScaleFactorMMPerDisplayUnit);
 }
 
 void mitk::DisplayGeometry::DisplayToWorld(const Vector2D &vec_display, Vector2D &vec_mm) const
 {
   vec_mm=vec_display*m_ScaleFactorMMPerDisplayUnit;
 }
 
 void mitk::DisplayGeometry::WorldToDisplay(const Vector2D &vec_mm, Vector2D &vec_display) const
 {
   vec_display=vec_mm*(1.0/m_ScaleFactorMMPerDisplayUnit);
 }
 
 void mitk::DisplayGeometry::ULDisplayToMM(const Point2D &pt_ULdisplay, Point2D &pt_mm) const
 {
   ULDisplayToDisplay(pt_ULdisplay, pt_mm);
   DisplayToWorld(pt_mm, pt_mm);
 }
 
 void mitk::DisplayGeometry::MMToULDisplay(const Point2D &pt_mm, Point2D &pt_ULdisplay) const
 {
   WorldToDisplay(pt_mm, pt_ULdisplay);
   DisplayToULDisplay(pt_ULdisplay, pt_ULdisplay);
 }
 
 void mitk::DisplayGeometry::ULDisplayToMM(const Vector2D &vec_ULdisplay, Vector2D &vec_mm) const
 {
   ULDisplayToDisplay(vec_ULdisplay, vec_mm);
   DisplayToWorld(vec_mm, vec_mm);
 }
 
 void mitk::DisplayGeometry::MMToULDisplay(const Vector2D &vec_mm, Vector2D &vec_ULdisplay) const
 {
   WorldToDisplay(vec_mm, vec_ULdisplay);
   DisplayToULDisplay(vec_ULdisplay, vec_ULdisplay);
 }
 
 void mitk::DisplayGeometry::ULDisplayToDisplay(const Point2D &pt_ULdisplay, Point2D &pt_display) const
 {
   pt_display[0]=pt_ULdisplay[0];
   pt_display[1]=GetDisplayHeight()-pt_ULdisplay[1];
 }
 
 void mitk::DisplayGeometry::DisplayToULDisplay(const Point2D &pt_display, Point2D &pt_ULdisplay) const
 {
   ULDisplayToDisplay(pt_display, pt_ULdisplay);
 }
 
 void mitk::DisplayGeometry::ULDisplayToDisplay(const Vector2D &vec_ULdisplay, Vector2D &vec_display) const
 {
   vec_display[0]= vec_ULdisplay[0];
   vec_display[1]=-vec_ULdisplay[1];
 }
 
 void mitk::DisplayGeometry::DisplayToULDisplay(const Vector2D &vec_display, Vector2D &vec_ULdisplay) const
 {
   ULDisplayToDisplay(vec_display, vec_ULdisplay);
 }
 
 bool mitk::DisplayGeometry::Project(const Point3D &pt3d_mm, Point3D &projectedPt3d_mm) const
 {
   if(m_WorldGeometry.IsNotNull())
   {
     return m_WorldGeometry->Project(pt3d_mm, projectedPt3d_mm);
   }
   else
   {
     return false;
   }
  }
 
 bool mitk::DisplayGeometry::Project(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const
 {
   if(m_WorldGeometry.IsNotNull())
   {
     return m_WorldGeometry->Project(atPt3d_mm, vec3d_mm, projectedVec3d_mm);
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::DisplayGeometry::Project(const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const
 {
    if(m_WorldGeometry.IsNotNull())
    {
       return m_WorldGeometry->Project(vec3d_mm, projectedVec3d_mm);
    }
    else
    {
       return false;
    }
 }
 
 bool mitk::DisplayGeometry::Map(const Point3D &pt3d_mm, Point2D &pt2d_mm) const
 {
   if(m_WorldGeometry.IsNotNull())
   {
     return m_WorldGeometry->Map(pt3d_mm, pt2d_mm);
   }
   else
   {
     return false;
   }
 }
 
 void mitk::DisplayGeometry::Map(const Point2D &pt2d_mm, Point3D &pt3d_mm) const
 {
   if(m_WorldGeometry.IsNull()) return;
   m_WorldGeometry->Map(pt2d_mm, pt3d_mm);
 }
 
 bool mitk::DisplayGeometry::Map(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector2D &vec2d_mm) const
 {
   if(m_WorldGeometry.IsNotNull())
   {
     return m_WorldGeometry->Map(atPt3d_mm, vec3d_mm, vec2d_mm);
   }
   else
   {
     return false;
   }
 }
 
 void mitk::DisplayGeometry::Map(const Point2D & atPt2d_mm, const Vector2D &vec2d_mm, Vector3D &vec3d_mm) const
 {
   if(m_WorldGeometry.IsNull()) return;
 
   m_WorldGeometry->Map(atPt2d_mm, vec2d_mm, vec3d_mm);
 }
 
 
 
 
 
 // protected methods
 
 mitk::DisplayGeometry::DisplayGeometry()
 :m_ScaleFactorMMPerDisplayUnit(1.0)
 ,m_WorldGeometry(NULL)
 ,m_ConstrainZoomingAndPanning(true)
 ,m_MaxWorldViewPercentage(1.0)
 ,m_MinWorldViewPercentage(0.1)
 {
   m_OriginInMM.Fill(0.0);
   m_OriginInDisplayUnits.Fill(0.0);
   m_SizeInMM.Fill(1.0);
   m_SizeInDisplayUnits.Fill(10.0);
 }
 
 mitk::DisplayGeometry::~DisplayGeometry()
 {
 }
 
 bool mitk::DisplayGeometry::RefitVisibleRect()
 {
   // do nothing if not asked to
   if (!m_ConstrainZoomingAndPanning) return false;
 
   // don't allow recursion (need to be fixed, singleton)
   static bool inRecalculate = false;
   if (inRecalculate) return false;
   inRecalculate = true;
 
   // rename some basic measures of the current viewport and world geometry (MM = milimeters Px = Pixels = display units)
   float displayXMM = m_OriginInMM[0];
   float displayYMM = m_OriginInMM[1];
   float displayWidthPx  = m_SizeInDisplayUnits[0];
   float displayHeightPx = m_SizeInDisplayUnits[1];
   float displayWidthMM  = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
   float displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;
 
   float worldWidthMM  = m_WorldGeometry->GetParametricExtentInMM(0);
   float worldHeightMM = m_WorldGeometry->GetParametricExtentInMM(1);
 
   // reserve variables for the correction logic to save a corrected origin and zoom factor
   Vector2D newOrigin = m_OriginInMM;
   bool correctPanning = false;
 
   float newScaleFactor = m_ScaleFactorMMPerDisplayUnit;
   bool correctZooming = false;
 
   // start of the correction logic
 
   // zoom to big means:
   // at a given percentage of the world's width/height should be visible. Otherwise
   // the whole screen could show only one pixel
   //
   // zoom to small means:
   // zooming out should be limited at the point where the smaller of the world's sides is completely visible
 
   bool zoomXtooSmall = displayWidthPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldWidthMM;
   bool zoomXtooBig = displayWidthPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldWidthMM;
 
   bool zoomYtooSmall = displayHeightPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldHeightMM;
   bool zoomYtooBig = displayHeightPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldHeightMM;
 
   // constrain zooming in both direction
   if ( zoomXtooBig && zoomYtooBig)
   {
     double fx = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
     double fy = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
     newScaleFactor = fx < fy ? fx : fy;
     correctZooming = true;
   }
   // constrain zooming in x direction
   else if ( zoomXtooBig )
   {
     newScaleFactor = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
     correctZooming = true;
   }
 
   // constrain zooming in y direction
   else if ( zoomYtooBig )
   {
     newScaleFactor = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
     correctZooming = true;
   }
 
   // constrain zooming out
   // we stop zooming out at these situations:
   //
   // *** display
   // --- image
   //
   //   **********************
   //   *                    *     x side maxed out
   //   *                    *
   //   *--------------------*
   //   *|                  |*
   //   *|                  |*
   //   *--------------------*
   //   *                    *
   //   *                    *
   //   *                    *
   //   **********************
   //
   //   **********************
   //   *     |------|       *     y side maxed out
   //   *     |      |       *
   //   *     |      |       *
   //   *     |      |       *
   //   *     |      |       *
   //   *     |      |       *
   //   *     |      |       *
   //   *     |      |       *
   //   *     |------|       *
   //   **********************
   //
   // In both situations we center the not-maxed out direction
   //
 if ( zoomXtooSmall && zoomYtooSmall )
     {
       // determine and set the bigger scale factor
       float fx = worldWidthMM * m_MaxWorldViewPercentage / displayWidthPx;
       float fy = worldHeightMM * m_MaxWorldViewPercentage / displayHeightPx;
       newScaleFactor = fx > fy ? fx : fy;
 
       correctZooming = true;
     }
 
 
   // actually execute correction
   if (correctZooming)
   {
     SetScaleFactor(newScaleFactor);
   }
 
   displayWidthMM  = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
   displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;
 
   // constrain panning
   if(worldWidthMM<displayWidthMM)
   {
     // zoomed out too much in x (but tolerated because y is still ok)
     // --> center x
     newOrigin[0] = (worldWidthMM - displayWidthMM) / 2.0;
     correctPanning = true;
   }
   else
   {
     // make sure left display border inside our world
     if (displayXMM < 0)
     {
       newOrigin[0] = 0;
       correctPanning = true;
     }
     // make sure right display border inside our world
     else  if (displayXMM + displayWidthMM > worldWidthMM)
     {
       newOrigin[0] = worldWidthMM - displayWidthMM;
       correctPanning = true;
     }
   }
 
 
   if (worldHeightMM<displayHeightMM)
   {
     // zoomed out too much in y (but tolerated because x is still ok)
     // --> center y
     newOrigin[1] = (worldHeightMM - displayHeightMM) / 2.0;
     correctPanning = true;
   }
   else
   {
     // make sure top display border inside our world
     if (displayYMM + displayHeightMM >  worldHeightMM)
     {
       newOrigin[1] = worldHeightMM - displayHeightMM;
       correctPanning = true;
     }
   // make sure bottom display border inside our world
     else
     if (displayYMM < 0)
     {
       newOrigin[1] = 0;
       correctPanning = true;
     }
 
   }
 
  if (correctPanning)
   {
     SetOriginInMM( newOrigin );
   }
 
   inRecalculate = false;
 
   if ( correctPanning || correctZooming )
   {
     Modified();
   }
 
   // return true if any correction has been made
   return correctPanning || correctZooming;
 }
 
 void mitk::DisplayGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   if(m_WorldGeometry.IsNull())
   {
     os << indent << " WorldGeometry: " << "NULL" << std::endl;
   }
   else
   {
     m_WorldGeometry->Print(os, indent);
     os << indent << " OriginInMM: " << m_OriginInMM << std::endl;
     os << indent << " OriginInDisplayUnits: " << m_OriginInDisplayUnits << std::endl;
     os << indent << " SizeInMM: " << m_SizeInMM << std::endl;
     os << indent << " SizeInDisplayUnits: " << m_SizeInDisplayUnits << std::endl;
     os << indent << " ScaleFactorMMPerDisplayUni: " << m_ScaleFactorMMPerDisplayUnit << std::endl;
   }
 
   Superclass::PrintSelf(os,indent);
 }
 
diff --git a/Core/Code/DataManagement/mitkGeometry2DData.cpp b/Core/Code/DataManagement/mitkGeometry2DData.cpp
index 215dcde56d..3d87886121 100644
--- a/Core/Code/DataManagement/mitkGeometry2DData.cpp
+++ b/Core/Code/DataManagement/mitkGeometry2DData.cpp
@@ -1,90 +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 "mitkBaseProcess.h"
+#include <mitkProportionalTimeGeometry.h>
 
 mitk::Geometry2DData::Geometry2DData()
 {
 }
 
 mitk::Geometry2DData::~Geometry2DData()
 {
 }
 
 void mitk::Geometry2DData::SetGeometry(mitk::Geometry3D *geometry)
 {
   if(geometry==NULL)
     SetGeometry2D(NULL);
   else
   {
     Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(geometry);
     if(geometry2d==NULL)
       itkExceptionMacro(<<"Trying to set a geometry which is not a Geometry2D into Geometry2DData.");
     SetGeometry2D(geometry2d);
   }
 }
 
 void mitk::Geometry2DData::SetGeometry2D(mitk::Geometry2D *geometry2d)
 {
   if(geometry2d != NULL)
   {
-    TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
-    if(timeSlicedGeometry == NULL)
-    {
-      Superclass::SetGeometry(geometry2d);
-      return;
-    }
-    timeSlicedGeometry->InitializeEvenlyTimed(geometry2d, 1);
+    ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+    timeGeometry->Initialize(geometry2d, 1);
+    SetTimeGeometry(timeGeometry);
     Modified();
   }
   else
     Superclass::SetGeometry(geometry2d);
 }
 
 void mitk::Geometry2DData::UpdateOutputInformation()
 {
   Superclass::UpdateOutputInformation();
 }
 
 void mitk::Geometry2DData::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 
 bool mitk::Geometry2DData::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   if(GetGeometry2D()==NULL) return true;
 
   return false;
 }
 
 bool mitk::Geometry2DData::VerifyRequestedRegion()
 {
   if(GetGeometry2D()==NULL) return false;
 
   return true;
 }
 
 void mitk::Geometry2DData::SetRequestedRegion( const itk::DataObject *)
 {
 
 }
 
 void mitk::Geometry2DData::CopyInformation(const itk::DataObject *)
 {
 }
diff --git a/Core/Code/DataManagement/mitkGeometry3D.cpp b/Core/Code/DataManagement/mitkGeometry3D.cpp
index 715a1e96d8..49433724d1 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkGeometry3D.cpp
@@ -1,909 +1,967 @@
 /*===================================================================
 
 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 "mitkGeometry3D.h"
 #include "mitkMatrixConvert.h"
 #include "mitkRotationOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkPointOperation.h"
 #include "mitkInteractionConst.h"
 
 #include <vtkMatrixToLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Standard constructor for the New() macro. Sets the geometry to 3 dimensions
 mitk::Geometry3D::Geometry3D()
   : m_ParametricBoundingBox(NULL),
     m_ImageGeometry(false), m_Valid(true), m_FrameOfReferenceID(0), m_IndexToWorldTransformLastModified(0)
 {
   FillVector3D(m_FloatSpacing, 1,1,1);
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   Initialize();
 }
 mitk::Geometry3D::Geometry3D(const Geometry3D& other) : Superclass(), mitk::OperationActor(), m_ParametricBoundingBox(other.m_ParametricBoundingBox),m_TimeBounds(other.m_TimeBounds),
   m_ImageGeometry(other.m_ImageGeometry), m_Valid(other.m_Valid), m_FrameOfReferenceID(other.m_FrameOfReferenceID), m_IndexToWorldTransformLastModified(other.m_IndexToWorldTransformLastModified), m_RotationQuaternion( other.m_RotationQuaternion ) , m_Origin(other.m_Origin)
 {
   // AffineGeometryFrame
   SetBounds(other.GetBounds());
   //SetIndexToObjectTransform(other.GetIndexToObjectTransform());
   //SetObjectToNodeTransform(other.GetObjectToNodeTransform());
   //SetIndexToWorldTransform(other.GetIndexToWorldTransform());
   // this is not used in AffineGeometryFrame of ITK, thus there are not Get and Set methods
   // m_IndexToNodeTransform = other.m_IndexToNodeTransform;
   // m_InvertedTransform = TransformType::New();
   // m_InvertedTransform = TransformType::New();
   // m_InvertedTransform->DeepCopy(other.m_InvertedTransform);
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkMatrix->DeepCopy(other.m_VtkMatrix);
   if (other.m_ParametricBoundingBox.IsNotNull())
   {
     m_ParametricBoundingBox = other.m_ParametricBoundingBox->DeepCopy();
   }
   FillVector3D(m_FloatSpacing,other.m_FloatSpacing[0],other.m_FloatSpacing[1],other.m_FloatSpacing[2]);
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->DeepCopy(other.m_VtkIndexToWorldTransform);
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   other.InitializeGeometry(this);
 }
 
 mitk::Geometry3D::~Geometry3D()
 {
   m_VtkMatrix->Delete();
   m_VtkIndexToWorldTransform->Delete();
 }
 
 
 static void CopySpacingFromTransform(mitk::AffineTransform3D* transform, mitk::Vector3D& spacing, float floatSpacing[3])
 {
   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();
   floatSpacing[0]=spacing[0];
   floatSpacing[1]=spacing[1];
   floatSpacing[2]=spacing[2];
 }
 
 
 void mitk::Geometry3D::Initialize()
 {
   float b[6] = {0,1,0,1,0,1};
   SetFloatBounds(b);
 
-  m_IndexToObjectTransform = TransformType::New();
-  m_ObjectToNodeTransform = TransformType::New();
-
   if(m_IndexToWorldTransform.IsNull())
     m_IndexToWorldTransform = TransformType::New();
   else
     m_IndexToWorldTransform->SetIdentity();
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   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;
 }
 
 void mitk::Geometry3D::TransferItkToVtkTransform()
 {
   // copy m_IndexToWorldTransform into m_VtkIndexToWorldTransform
   TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix);
   m_VtkIndexToWorldTransform->Modified();
 }
 
 void mitk::Geometry3D::TransferVtkToItkTransform()
 {
   TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer());
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
 }
 
 void mitk::Geometry3D::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix)
 {
   m_VtkMatrix->DeepCopy(vtkmatrix);
   TransferVtkToItkTransform();
 }
 
 void mitk::Geometry3D::SetTimeBounds(const TimeBounds& timebounds)
 {
   if(m_TimeBounds != timebounds)
   {
     m_TimeBounds = timebounds;
     Modified();
   }
 }
 
 void mitk::Geometry3D::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++;
-  SetBoundsArray(b, m_BoundingBox);
+  SetBounds(b);
 }
 
 void mitk::Geometry3D::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++;
-  SetBoundsArray(b, m_BoundingBox);
+  SetBounds(b);
 }
 
 void mitk::Geometry3D::SetParametricBounds(const BoundingBox::BoundsArrayType& bounds)
 {
-  SetBoundsArray(bounds, m_ParametricBoundingBox);
+  m_ParametricBoundingBox = 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<NDimensions; ++i)
+      {
+      p[i] = bounds[2*i+pointid];
+      }
+    pointscontainer->InsertElement(pointid, p);
+    }
+
+  m_ParametricBoundingBox->SetPoints(pointscontainer);
+  m_ParametricBoundingBox->ComputeBoundingBox();
+  this->Modified();
 }
 
 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const
 {
   BackTransform(pt_mm, pt_units);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const
 {
   pt_mm = m_IndexToWorldTransform->TransformPoint(pt_units);
 }
 
 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D & /*atPt3d_mm*/, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::WorldToIndex(point, vec, vec). Use Geometry3D::WorldToIndex(vec, vec) instead!";
   //BackTransform(atPt3d_mm, vec_mm, vec_units);
   this->WorldToIndex(vec_mm, vec_units);
 }
 
 void mitk::Geometry3D::WorldToIndex( const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   BackTransform( vec_mm, vec_units);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &/*atPt3d_units*/, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::IndexToWorld(point, vec, vec). Use Geometry3D::IndexToWorld(vec, vec) instead!";
   //vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
   this->IndexToWorld(vec_units, vec_mm);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
 }
 
 void mitk::Geometry3D::SetIndexToWorldTransform(mitk::AffineTransform3D* transform)
 {
   if(m_IndexToWorldTransform.GetPointer() != transform)
   {
-    Superclass::SetIndexToWorldTransform(transform);
+    m_IndexToWorldTransform = transform;
     CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
     vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
     TransferItkToVtkTransform();
     Modified();
   }
 }
 
 itk::LightObject::Pointer mitk::Geometry3D::InternalClone() const
 {
   Self::Pointer newGeometry = new Self(*this);
   newGeometry->UnRegister();
   return newGeometry.GetPointer();
 }
 /*
 void mitk::Geometry3D::InitializeGeometry(Geometry3D * newGeometry) const
 {
   Superclass::InitializeGeometry(newGeometry);
 
   newGeometry->SetTimeBounds(m_TimeBounds);
 
   //newGeometry->GetVtkTransform()->SetMatrix(m_VtkIndexToWorldTransform->GetMatrix()); IW
   //newGeometry->TransferVtkToItkTransform(); //MH
 
   newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID());
   newGeometry->m_ImageGeometry = m_ImageGeometry;
 }
 */
 void mitk::Geometry3D::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();
   }
 }
 
 mitk::BoundingBox::Pointer mitk::Geometry3D::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;
 }
 
 #include <vtkTransform.h>
 void mitk::Geometry3D::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;
   }
 
   default:
     vtktransform->Delete();
     return;
   }
   m_VtkMatrix->DeepCopy(vtktransform->GetMatrix());
   TransferVtkToItkTransform();
   Modified();
   vtktransform->Delete();
 }
 
 void mitk::Geometry3D::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];
     }
   }
 }
 
 void mitk::Geometry3D::BackTransform(const mitk::Point3D &/*at*/, const mitk::Vector3D &in, mitk::Vector3D& out) const
 {
   MITK_INFO<<"Warning! Call of the deprecated function Geometry3D::BackTransform(point, vec, vec). Use Geometry3D::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);
 }
 
 void mitk::Geometry3D::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];
     }
   }
 }
 
 const float* mitk::Geometry3D::GetFloatSpacing() const
 {
   return m_FloatSpacing;
 }
 
 void mitk::Geometry3D::SetSpacing(const mitk::Vector3D& aSpacing)
 {
   if(mitk::Equal(m_Spacing, aSpacing) == false)
   {
     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());
 
     itk2vtk(m_Spacing, m_FloatSpacing);
   }
 }
 
 void mitk::Geometry3D::SetOrigin(const Point3D & origin)
 {
   if(origin!=GetOrigin())
   {
     m_Origin = origin;
     m_IndexToWorldTransform->SetOffset(m_Origin.GetVectorFromOrigin());
     Modified();
     TransferItkToVtkTransform();
   }
 }
 
 void mitk::Geometry3D::Translate(const Vector3D & vector)
 {
     if((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0))
     {
         this->SetOrigin(m_Origin + vector);
 //        m_IndexToWorldTransform->SetOffset(m_IndexToWorldTransform->GetOffset()+vector);
 //        TransferItkToVtkTransform();
 //        Modified();
     }
 }
 
 void mitk::Geometry3D::SetIdentity()
 {
   m_IndexToWorldTransform->SetIdentity();
   m_Origin.Fill(0);
   Modified();
   TransferItkToVtkTransform();
 }
 
-void mitk::Geometry3D::Compose( const mitk::AffineGeometryFrame3D::TransformType * other, bool pre )
+void mitk::Geometry3D::Compose( const mitk::Geometry3D::TransformType * other, bool pre )
 {
   m_IndexToWorldTransform->Compose(other, pre);
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
   Modified();
   TransferItkToVtkTransform();
 }
 
 void mitk::Geometry3D::Compose( const vtkMatrix4x4 * vtkmatrix, bool pre )
 {
-  mitk::AffineGeometryFrame3D::TransformType::Pointer itkTransform = mitk::AffineGeometryFrame3D::TransformType::New();
+  mitk::Geometry3D::TransformType::Pointer itkTransform = mitk::Geometry3D::TransformType::New();
   TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer());
   Compose(itkTransform, pre);
 }
 
 const std::string mitk::Geometry3D::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::Geometry3D::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " IndexToWorldTransform: ";
   if(m_IndexToWorldTransform.IsNull())
     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 << m_IndexToWorldTransform->GetMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     os << indent << "Offset: " << m_IndexToWorldTransform->GetOffset() << std::endl;
     os << indent << "Center: " << m_IndexToWorldTransform->GetCenter() << std::endl;
     os << indent << "Translation: " << m_IndexToWorldTransform->GetTranslation() << std::endl;
 
     os << indent << "Inverse: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << m_IndexToWorldTransform->GetInverseMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     // from itk::ScalableAffineTransform
     os << indent << "Scale : ";
     for (i = 0; i < 3; i++)
     {
       os << m_IndexToWorldTransform->GetScale()[i] << " ";
     }
     os << std::endl;
   }
 
   os << indent << " BoundingBox: ";
   if(m_BoundingBox.IsNull())
     os << "NULL" << std::endl;
   else
   {
     os << indent << "( ";
     for (unsigned int i=0; i<3; i++)
     {
       os << m_BoundingBox->GetBounds()[2*i] << "," << m_BoundingBox->GetBounds()[2*i+1] << " ";
     }
     os << " )" << std::endl;
   }
 
   os << indent << " Origin: " << m_Origin << std::endl;
   os << indent << " ImageGeometry: " << m_ImageGeometry << std::endl;
   os << indent << " Spacing: " << m_Spacing << std::endl;
   os << indent << " TimeBounds: " << m_TimeBounds << std::endl;
 }
 
 mitk::Point3D mitk::Geometry3D::GetCornerPoint(int id) const
 {
   assert(id >= 0);
   assert(m_BoundingBox.IsNotNull());
 
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->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 m_IndexToWorldTransform->TransformPoint(cornerpoint);
 }
 
 mitk::Point3D mitk::Geometry3D::GetCornerPoint(bool xFront, bool yFront, bool zFront) const
 {
   assert(m_BoundingBox.IsNotNull());
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->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 m_IndexToWorldTransform->TransformPoint(cornerpoint);
 }
 
 void
 mitk::Geometry3D::ResetSubTransforms()
 {
 }
 
 void
 mitk::Geometry3D::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);
 }
 
 bool mitk::Geometry3D::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;
 }
 
 bool mitk::Equal( const mitk::Geometry3D::BoundingBoxType *leftHandSide, const mitk::Geometry3D::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose )
 {
   bool result = true;
   if( rightHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[( Geometry3D::BoundingBoxType )] rightHandSide NULL.";
     return false;
   }
   if( leftHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[( Geometry3D::BoundingBoxType )] leftHandSide NULL.";
     return false;
   }
 
   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)
   {
     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::Geometry3D *leftHandSide, const mitk::Geometry3D *rightHandSide, ScalarType eps, bool verbose)
 {
   bool result = true;
 
   if( rightHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[( Geometry3D )] rightHandSide NULL.";
     return false;
   }
   if( leftHandSide == NULL)
   {
     if(verbose)
       MITK_INFO << "[( Geometry3D )] leftHandSide NULL.";
     return false;
   }
 
   //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 Geometry3D::TransformType *leftHandSide, const Geometry3D::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;
 }
+
+/** Initialize the geometry */
+void
+mitk::Geometry3D::InitializeGeometry(Geometry3D* newGeometry) const
+{
+  newGeometry->SetBounds(m_BoundingBox->GetBounds());
+  // we have to create a new transform!!
+
+  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);
+  }
+}
+
+/** Set the bounds */
+void mitk::Geometry3D::SetBounds(const BoundsArrayType& 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<NDimensions; ++i)
+      {
+      p[i] = bounds[2*i+pointid];
+      }
+    pointscontainer->InsertElement(pointid, p);
+    }
+
+  m_BoundingBox->SetPoints(pointscontainer);
+  m_BoundingBox->ComputeBoundingBox();
+  this->Modified();
+}
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkGeometry3D.h b/Core/Code/DataManagement/mitkGeometry3D.h
index 3b665a55cb..19c97b45be 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.h
+++ b/Core/Code/DataManagement/mitkGeometry3D.h
@@ -1,723 +1,762 @@
 /*===================================================================
 
 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 <MitkExports.h>
 #include <mitkCommon.h>
 #include "mitkVector.h"
 #include "mitkOperationActor.h"
 
 #include <itkIndex.h>
 #include <itkBoundingBox.h>
 #include <itkQuaternionRigidTransform.h>
 #include <itkAffineGeometryFrame.h>
+#include "itkScalableAffineTransform.h"
+#include "itkBoundingBox.h"
 
 class vtkLinearTransform;
 class vtkMatrixToLinearTransform;
 class vtkMatrix4x4;
 
 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;
 
-typedef itk::AffineGeometryFrame<ScalarType, 3> AffineGeometryFrame3D;
+typedef itk::AffineGeometryFrame<ScalarType, 3>        AffineGeometryFrame3D;
+
 
 //##Documentation
 //## @brief Describes the geometry of a data object
 //##
 //## At least, it can return the bounding box of the 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.
 //##
 //## Geometry3D 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.
 //##
 //## Geometry3D instances referring to an Image need a slightly
 //## different definition of corners, see SetImageGeometry. This
 //## is usualy automatically called by Image.
 //##
 //## Geometry3D 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().
 //##
 //## Rule: everything is in mm (ms) if not stated otherwise.
 //## @ingroup Geometry
-class MITK_CORE_EXPORT Geometry3D : public AffineGeometryFrame3D, public OperationActor
+class MITK_CORE_EXPORT Geometry3D : public itk::Object, public OperationActor
 {
 public:
-  mitkClassMacro(Geometry3D, AffineGeometryFrame3D);
+  mitkClassMacro(Geometry3D, itk::Object);
 
   typedef itk::QuaternionRigidTransform< ScalarType > QuaternionTransformType;
   typedef QuaternionTransformType::VnlQuaternionType VnlQuaternionType;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
 
+typedef itk::ScalableAffineTransform<ScalarType, 3>    TransformType;
+typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
+typedef BoundingBoxType::BoundsArrayType               BoundsArrayType;
+typedef BoundingBoxType::Pointer                       BoundingBoxPointer;
+
   // 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
   virtual void SetIndexToWorldTransform(mitk::AffineTransform3D* transform);
   //##Documentation
   //## @brief Convenience method for setting the ITK transform
   //## (m_IndexToWorldTransform) via an vtkMatrix4x4
   //## \sa SetIndexToWorldTransform
   virtual void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix);
 
 #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
   {
     assert(m_BoundingBox.IsNotNull());
     return m_BoundingBox->GetBounds();
   }
+#endif
   //##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.
-virtual void SetBounds(const BoundsArrayType& bounds);
-#endif
+  virtual void SetBounds(const BoundsArrayType& bounds);
   //##Documentation
   //## @brief Set the bounding box (in index/unit coordinates) via a float array
   virtual void SetFloatBounds(const float bounds[6]);
   //##Documentation
   //## @brief Set the bounding box (in index/unit coordinates) via a double array
   virtual void SetFloatBounds(const double bounds[6]);
 
 
   //##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 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 time bounds (in ms)
   itkGetConstReferenceMacro(TimeBounds, TimeBounds);
   //##Documentation
   //## @brief Set the time bounds (in ms)
   virtual void SetTimeBounds(const TimeBounds& timebounds);
 
   //##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 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
   {
     Vector3D frontToBack;
     frontToBack.SetVnlVector(m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction));
     frontToBack *= GetExtent(direction);
     return frontToBack;
   }
 
   //##Documentation
   //## @brief Get the center of the bounding-box in mm
   //##
   Point3D GetCenter() const
   {
     assert(m_BoundingBox.IsNotNull());
     return m_IndexToWorldTransform->TransformPoint(m_BoundingBox->GetCenter());
   }
 
   //##Documentation
   //## @brief Get the squared length of the diagonal of the bounding-box in mm
   //##
   double 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 GetDiagonalLength() const
   {
     return sqrt(GetDiagonalLength2());
   }
 
   //##Documentation
   //## @brief Get a VnlVector along bounding-box in the specified
   //## @a direction, length is spacing
   //##
   //## \sa GetAxisVector
   VnlVector GetMatrixColumn(unsigned int direction) const
   {
     return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction);
   }
 
 #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
 
   //##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
   {
     return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction).magnitude()*GetExtent(direction);
   }
 
   //##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!
   virtual void SetExtentInMM(int direction, ScalarType extentInMM);
 
   //##Documentation
   //## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
   vtkLinearTransform* GetVtkTransform() const
   {
     return (vtkLinearTransform*)m_VtkIndexToWorldTransform;
   }
 
   //##Documentation
   //## @brief Set the origin, i.e. the upper-left corner of the plane
   //##
   virtual void SetOrigin(const Point3D& origin);
 
   //##Documentation
   //## @brief Translate the origin by a vector
   //##
   virtual void Translate(const Vector3D&  vector);
 
   //##Documentation
   //## @brief Set the transform to identity
   //##
   virtual void SetIdentity();
 
   //##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.
-  virtual void Compose( const AffineGeometryFrame3D::TransformType * other, bool pre = 0 );
+  virtual void Compose( const Geometry3D::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.
   virtual void Compose( const vtkMatrix4x4 * vtkmatrix, bool pre = 0 );
 
   //##Documentation
   //## @brief Get the origin, e.g. the upper-left corner of the plane
   const Point3D& GetOrigin() const
   {
     return m_Origin;
   }
 
   //##Documentation
   //## @brief Get the origin as VnlVector
   //##
   //## \sa GetOrigin
   VnlVector GetOriginVnl() const
   {
     return const_cast<Self*>(this)->m_Origin.GetVnlVector();
   }
 
   //##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 (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 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 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 (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 (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 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 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 Geometry3D 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);
   }
 
   //##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 Initialize the Geometry3D
   virtual void Initialize();
 
   //##Documentation
   //## @brief Is this an ImageGeometry?
   //##
   //## For more information, see SetImageGeometry
   itkGetConstMacro(ImageGeometry, bool);
   //##Documentation
   //## @brief Define that this Geometry3D 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.
   itkSetMacro(ImageGeometry, bool);
   itkBooleanMacro(ImageGeometry);
 
   //##Documentation
   //## @brief Is this Geometry3D in a state that is valid?
   virtual bool IsValid() const
   {
     return m_Valid;
   }
 
   //##Documentation
   //## @brief Test whether the point \a p (world coordinates in mm) is
   //## inside the bounding box
   bool IsInside(const mitk::Point3D& p) const
   {
     mitk::Point3D index;
     WorldToIndex(p, index);
     return IsIndexInside(index);
   }
 
   //##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
   {
     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 = m_BoundingBox->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 = m_BoundingBox->GetBounds();
         if((discretIndex[0] == bounds[1]) ||
            (discretIndex[1] == bounds[3]) ||
            (discretIndex[2] == bounds[5]))
          inside = false;
       }
     }
     else
       inside = m_BoundingBox->IsInside(index);
 
     return inside;
   }
 
   //##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);
   }
 
 
   //##Documentation
   //## @brief Get the spacing (size of a pixel).
   //##
   itkGetConstReferenceMacro(Spacing, mitk::Vector3D);
 
   //##Documentation
   //## @brief Get the spacing as a float[3] array.
   const float* GetFloatSpacing() const;
 
   //##Documentation
   //## @brief Set the spacing (m_Spacing)
   virtual void SetSpacing(const mitk::Vector3D& aSpacing);
 
   //##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);
 
   //##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();
 
   //##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
   {
     assert(m_ParametricBoundingBox.IsNotNull());
     return m_ParametricBoundingBox->GetBounds();
   }
 
   //##Documentation
   //## @brief Get the parametric extent
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   mitk::ScalarType GetParametricExtent(int direction) const
   {
-    assert(direction>=0 && direction<3);
+    if (direction < 0 || direction>=3)
+      mitkThrow() << "Invalid direction. Must be between either 0, 1 or 2. ";
     assert(m_ParametricBoundingBox.IsNotNull());
 
     BoundingBoxType::BoundsArrayType bounds = m_ParametricBoundingBox->GetBounds();
     return bounds[direction*2+1]-bounds[direction*2];
   }
 
   //##Documentation
   //## @brief Get the parametric extent in mm
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   virtual mitk::ScalarType GetParametricExtentInMM(int direction) const
   {
     return GetExtentInMM(direction);
   }
 
   //##Documentation
   //## @brief Get the parametric transform
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   virtual const Transform3D* GetParametricTransform() const
   {
     return m_IndexToWorldTransform;
   }
 
   //##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 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;
 
   //##Documentation
   //##@brief executes affine operations (translate, rotate, scale)
   virtual void ExecuteOperation(Operation* operation);
 
+
+
+  /** Set/Get the IndexToWorldTransform */
+  itkGetConstObjectMacro(IndexToWorldTransform, AffineTransform3D);
+  itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
+  /** Get the bounding box */
+  itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
+
+  const BoundsArrayType GetBounds() const
+    {
+    assert(m_BoundingBox.IsNotNull());
+    return m_BoundingBox->GetBounds();
+    }
+
+  /** Get the extent of the bounding box */
+  ScalarType GetExtent(unsigned int direction) const
+    {
+    assert(m_BoundingBox.IsNotNull());
+    if (direction>=NDimensions)
+      mitkThrow() << "Direction is too big. This geometry is for " << NDimensions << " Data";
+    BoundsArrayType bounds = m_BoundingBox->GetBounds();
+    return bounds[direction*2+1]-bounds[direction*2];
+    }
 protected:
   Geometry3D();
   Geometry3D(const Geometry3D& other);
 
+
+  virtual void InitializeGeometry(Self * newGeometry) const;
+
   static const std::string GetTransformAsString( TransformType* transformType );
+  static const unsigned int NDimensions = 3;
 
   virtual ~Geometry3D();
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
   virtual void BackTransform(const mitk::Point3D& in, mitk::Point3D& out) const;
   //##Documentation
   //## @brief Deprecated
   virtual void BackTransform(const mitk::Point3D& at, const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
   //Without redundant parameter Point3D
   virtual void BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
   //##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);
 
   /** Resets sub-transforms that compose m_IndexToWorldTransform, by using
    * the current value of m_IndexToWorldTransform and setting the rotation
    * component to zero. */
   virtual void ResetSubTransforms();
 
   mutable mitk::BoundingBox::Pointer m_ParametricBoundingBox;
 
   mutable mitk::TimeBounds m_TimeBounds;
 
   vtkMatrix4x4* m_VtkMatrix;
 
   bool m_ImageGeometry;
 
+  AffineTransform3D::Pointer m_IndexToWorldTransform;
+  mutable BoundingBoxPointer m_BoundingBox;
+
   //##Documentation
   //## @brief Spacing of the data. Only significant if the geometry describes
   //## an Image (m_ImageGeometry==true).
   mitk::Vector3D m_Spacing;
 
   bool m_Valid;
 
   unsigned int m_FrameOfReferenceID;
 
   static const std::string INDEX_TO_OBJECT_TRANSFORM;
   static const std::string OBJECT_TO_NODE_TRANSFORM;
   static const std::string INDEX_TO_NODE_TRANSFORM;
   static const std::string INDEX_TO_WORLD_TRANSFORM;
 
 private:
   mutable TransformType::Pointer m_InvertedTransform;
   mutable unsigned long m_IndexToWorldTransformLastModified;
 
   VnlQuaternionType m_RotationQuaternion;
 
 
   float m_FloatSpacing[3];
   vtkMatrixToLinearTransform* m_VtkIndexToWorldTransform;
 
   //##Documentation
   //## @brief Origin, i.e. upper-left corner of the plane
   //##
   Point3D m_Origin;
 };
 
 //
 // Static compare functions mainly for testing
 //
 /**
  * @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::Geometry3D* leftHandSide, const mitk::Geometry3D* 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::Geometry3D::TransformType *leftHandSide, const mitk::Geometry3D::TransformType *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::Geometry3D::BoundingBoxType *leftHandSide, const mitk::Geometry3D::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose);
 
 } // namespace mitk
 
 #endif /* GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkImage.cpp b/Core/Code/DataManagement/mitkImage.cpp
index b27692fab1..b18f18525f 100644
--- a/Core/Code/DataManagement/mitkImage.cpp
+++ b/Core/Code/DataManagement/mitkImage.cpp
@@ -1,1374 +1,1384 @@
 /*===================================================================
 
 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 "mitkCompareImageFilter.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
-  this->SetGeometry(dynamic_cast<mitk::TimeSlicedGeometry*>(other.GetTimeSlicedGeometry()->Clone().GetPointer()));
+  itk::LightObject::Pointer cloned = other.GetTimeGeometry()->Clone();
+  this->SetTimeGeometry(dynamic_cast<TimeGeometry*>(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;
 
-
-  float *fspacing = const_cast<float *>(GetSlicedGeometry(t)->GetFloatSpacing());
+  SlicedGeometry3D* geom3d = GetSlicedGeometry(t);
+  float *fspacing = const_cast<float *>(geom3d->GetFloatSpacing());
   double dspacing[3] = {fspacing[0],fspacing[1],fspacing[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);
   }
 
-  TimeSlicedGeometry::Pointer timeSliceGeometry = TimeSlicedGeometry::New();
-  timeSliceGeometry->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
-  timeSliceGeometry->ImageGeometryOn();
-
-  SetGeometry(timeSliceGeometry);
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
+  for (TimeStepType step = 0; step < timeGeometry->GetNumberOfTimeSteps(); ++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::Geometry3D& geometry, unsigned int channels, int tDim )
 {
+  mitk::ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  Geometry3D::Pointer geometry3D = geometry.Clone();
+  timeGeometry->Initialize(geometry3D.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 )
+{
+  const ProportionalTimeGeometry& ptG = dynamic_cast<const ProportionalTimeGeometry&>(geometry);
   unsigned int dimensions[5];
-  dimensions[0] = (unsigned int)(geometry.GetExtent(0)+0.5);
-  dimensions[1] = (unsigned int)(geometry.GetExtent(1)+0.5);
-  dimensions[2] = (unsigned int)(geometry.GetExtent(2)+0.5);
-  dimensions[3] = 0;
+  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.GetNumberOfTimeSteps();
   dimensions[4] = 0;
 
   unsigned int dimension = 2;
   if ( dimensions[2] > 1 )
     dimension = 3;
-
-  if ( tDim > 0)
-  {
-    dimensions[3] = tDim;
-  }
-  else
-  {
-    const mitk::TimeSlicedGeometry* timeGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>(&geometry);
-    if ( timeGeometry != NULL )
-    {
-      dimensions[3] = timeGeometry->GetTimeSteps();
-    }
-  }
-
   if ( dimensions[3] > 1 )
     dimension = 4;
 
   Initialize( type, dimension, dimensions, channels );
-
-  SetGeometry(static_cast<Geometry3D*>(geometry.Clone().GetPointer()));
-
-  mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBox()->GetBounds();
+  if (geometry.GetNumberOfTimeSteps() > 1)
+  {
+    itk::LightObject::Pointer cloned = geometry.Clone();
+    SetTimeGeometry(dynamic_cast<TimeGeometry *>(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());
 
-    GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
-  }
+    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::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
 {
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
   slicedGeometry->InitializeEvenlySpaced(static_cast<Geometry2D*>(geometry2d.Clone().GetPointer()), sDim, flipped);
   Initialize(type, *slicedGeometry, channels, tDim);
 }
 
 void mitk::Image::Initialize(const mitk::Image* image)
 {
-  Initialize(image->GetPixelType(), *image->GetTimeSlicedGeometry());
+  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;
   vtkFloatingPointType 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->SetOrigin(origin);
 
   // re-initialize SlicedGeometry3D
   slicedGeometry->SetOrigin(origin);
   slicedGeometry->SetSpacing(spacing);
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
+
+  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(Geometry3D* 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);
-  GetTimeSlicedGeometry()->ImageGeometryOn();
+  for (TimeStepType step = 0; step < GetTimeGeometry()->GetNumberOfTimeSteps(); ++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::Geometry3D* geo = this->GetGeometry();
   bool ret = false;
 
   if(geo)
   {
     const vnl_matrix_fixed<float, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
     float 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* rightHandSide, const mitk::Image* leftHandSide, ScalarType eps, bool verbose)
 {
   bool returnValue = true;
   if( rightHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[( Image )] rightHandSide is NULL.";
     return false;
   }
 
   if( leftHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[( Image )] leftHandSide is NULL.";
     return false;
   }
 
   // Dimensionality
   if( rightHandSide->GetDimension() != leftHandSide->GetDimension() )
   {
     if(verbose)
     {
       MITK_INFO << "[( Image )] Dimensionality differs.";
       MITK_INFO << "rightHandSide is " << rightHandSide->GetDimension()
                 << "leftHandSide is " << leftHandSide->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 << "rightHandSide->GetDimension("<<i<<") is " << rightHandSide->GetDimension(i)
                   << "leftHandSide->GetDimension("<<i<<") is " << leftHandSide->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 << "rightHandSide is " << pixelTypeRightHandSide.GetTypeAsString()
                 << "leftHandSide is " << pixelTypeLeftHandSide.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::CompareImageFilter::Pointer compareFilter = mitk::CompareImageFilter::New();
     compareFilter->SetInput(0, rightHandSide);
     compareFilter->SetInput(1, leftHandSide);
     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 ce210074e4..d3159b67f0 100644
--- a/Core/Code/DataManagement/mitkImage.h
+++ b/Core/Code/DataManagement/mitkImage.h
@@ -1,692 +1,712 @@
 /*===================================================================
 
 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 <MitkExports.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.
 //## @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);
 
   itkNewMacro(Self);
 
   mitkCloneMacro(Image);
 
   /** 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
   //##
-  //## @param tDim override time dimension (@a n[3]) if @a geometry is a TimeSlicedGeometry (if >0)
-  virtual void Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels = 1, int tDim=-1);
+  //## @param tDim defines the number of time steps for which the Image should be initialized
+  virtual void Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels = 1, int tDim=1);
+
+  /**
+  * initialize new (or re-initialize) image information by a Geometry3D
+  *
+  * @param tDim defines the number of time steps for which the Image should be initialized
+  * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
+  */
+  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 Geometry2D and number of slices
   //##
   //## Initializes the bounding box according to the width/height of the
   //## Geometry2D and @a sDim via SlicedGeometry3D::InitializeEvenlySpaced.
   //## The spacing is calculated from the Geometry2D.
-  //## @param tDim override time dimension (@a n[3]) if @a geometry is a TimeSlicedGeometry (if >0)
   //## \sa SlicedGeometry3D::InitializeEvenlySpaced
-  virtual void Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped = false, unsigned int channels = 1, int tDim=-1);
+  virtual void Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& 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 Geometry2D 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->SetOrigin(origin);
     planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
     // re-initialize SlicedGeometry3D
     SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
     slicedGeometry->InitializeEvenlySpaced(planeGeometry, m_Dimensions[2]);
     slicedGeometry->SetSpacing(spacing);
 
-    // re-initialize TimeSlicedGeometry
-    GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
+    // 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(Geometry3D* 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:
 
   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
  *
  * @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/mitkImageToItk.txx b/Core/Code/DataManagement/mitkImageToItk.txx
index 110fcdfdb3..973d5c46af 100644
--- a/Core/Code/DataManagement/mitkImageToItk.txx
+++ b/Core/Code/DataManagement/mitkImageToItk.txx
@@ -1,258 +1,258 @@
 /*===================================================================
 
 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 IMAGETOITK_TXX_INCLUDED_C1C2FCD2
 #define IMAGETOITK_TXX_INCLUDED_C1C2FCD2
 
 #include "mitkImageToItk.h"
 #include "mitkBaseProcess.h"
 #include "itkImportMitkImageContainer.h"
 #include "mitkImageWriteAccessor.h"
 #include "mitkException.h"
 
 
 template <class TOutputImage>
 void mitk::ImageToItk<TOutputImage>::SetInput(mitk::Image *input)
 {
   if(input == NULL)
     itkExceptionMacro( << "image is null" );
   if(input->GetDimension()!=TOutputImage::GetImageDimension())
     itkExceptionMacro( << "image has dimension " << input->GetDimension() << " instead of " << TOutputImage::GetImageDimension() );
 
 
   if(!(input->GetPixelType() == mitk::MakePixelType<TOutputImage>()))
     itkExceptionMacro( << "image has wrong pixel type " );
 
   // Process object is not const-correct so the const_cast is required here
   itk::ProcessObject::SetNthInput(0, input);
 }
 
 template<class TOutputImage>
 void mitk::ImageToItk<TOutputImage>::SetInput( unsigned int index, mitk::Image * input )
 {
   if( index+1 > this->GetNumberOfInputs() )
   {
     this->SetNumberOfRequiredInputs( index + 1 );
   }
 
   if(input == NULL)
     itkExceptionMacro( << "image is null" );
   if(input->GetDimension()!=TOutputImage::GetImageDimension())
     itkExceptionMacro( << "image has dimension " << input->GetDimension() << " instead of " << TOutputImage::GetImageDimension() );
 
 
   if(!(input->GetPixelType() == mitk::MakePixelType<TOutputImage>() ))
     itkExceptionMacro( << "image has wrong pixel type " );
 
   // Process object is not const-correct so the const_cast is required here
   itk::ProcessObject::SetNthInput(index,input);
 }
 
 template<class TOutputImage>
 mitk::Image *mitk::ImageToItk<TOutputImage>::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return (mitk::Image*) const_cast<itk::DataObject*>(itk::ProcessObject::GetInput(0));
 }
 
 template<class TOutputImage>
 mitk::Image *mitk::ImageToItk<TOutputImage>::GetInput(unsigned int idx)
 {
   return itk::ProcessObject::GetInput(idx);
 }
 
 template<class TOutputImage>
   void mitk::ImageToItk<TOutputImage>
   ::GenerateData()
 {
   // Allocate output
   mitk::Image::Pointer input = this->GetInput();
   typename Superclass::OutputImageType::Pointer output = this->GetOutput();
 
 
   unsigned long noBytes = input->GetDimension(0);
   for (unsigned int i=1; i<TOutputImage::GetImageDimension(); ++i)
   {
     noBytes = noBytes * input->GetDimension(i);
   }
 
   mitk::ImageWriteAccessor* imageAccess = new mitk::ImageWriteAccessor(input);
 
   // hier wird momentan wohl nur der erste Channel verwendet??!!
   if(imageAccess->GetData() == NULL)
   {
     itkWarningMacro(<< "no image data to import in ITK image");
 
     RegionType bufferedRegion;
     output->SetBufferedRegion(bufferedRegion);
     return;
   }
 
   if (m_CopyMemFlag)
   {
     itkDebugMacro("copyMem ...");
 
     output->Allocate();
 
     memcpy( (PixelType *) output->GetBufferPointer(), imageAccess->GetData(), sizeof(PixelType)*noBytes);
 
     delete imageAccess;
   }
   else
   {
     itkDebugMacro("do not copyMem ...");
     typedef itk::ImportMitkImageContainer< unsigned long, PixelType >   ImportContainerType;
     typename ImportContainerType::Pointer import;
 
     import = ImportContainerType::New();
     import->Initialize();
 
     itkDebugMacro( << "size of container = " << import->Size() );
     //import->SetImageDataItem(m_ImageDataItem);
     import->SetImageAccessor(imageAccess,sizeof(PixelType)*noBytes);
 
-    output->SetPixelContainer(import);
+     output->SetPixelContainer(import);
     itkDebugMacro( << "size of container = " << import->Size() );
   }
 }
 
 template<class TOutputImage>
   void mitk::ImageToItk<TOutputImage>
   ::UpdateOutputInformation()
 {
   mitk::Image::Pointer input = this->GetInput();
   if(input.IsNotNull() && (input->GetSource().IsNotNull()) && input->GetSource()->Updating())
   {
     typename Superclass::OutputImageType::Pointer output = this->GetOutput();
     unsigned long t1 = input->GetUpdateMTime()+1;
     if (t1 > this->m_OutputInformationMTime.GetMTime())
     {
       output->SetPipelineMTime(t1);
 
       this->GenerateOutputInformation();
 
       this->m_OutputInformationMTime.Modified();
     }
     return;
   }
   Superclass::UpdateOutputInformation();
 }
 
 template<class TOutputImage>
   void mitk::ImageToItk<TOutputImage>
   ::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   typename Superclass::OutputImageType::Pointer output = this->GetOutput();
 
   // allocate size, origin, spacing, direction in types of output image
   SizeType  size;
   const unsigned int itkDimMin3 = (TOutputImage::ImageDimension > 3 ? TOutputImage::ImageDimension : 3);
   const unsigned int itkDimMax3 = (TOutputImage::ImageDimension < 3 ? TOutputImage::ImageDimension : 3);
   typename Superclass::OutputImageType::PointType::ValueType origin[ itkDimMin3 ];
   typename Superclass::OutputImageType::SpacingType::ComponentType spacing[ itkDimMin3 ];
   typename Superclass::OutputImageType::DirectionType direction;
 
   // copy as much information as possible into size and spacing
   unsigned int i;
   for ( i=0; i < itkDimMax3; ++i)
   {
      size[i]    = input->GetDimension(i);
      spacing[i] = input->GetGeometry()->GetSpacing()[i];
   }
   for ( ; i < TOutputImage::ImageDimension; ++i)
   {
      origin[i]  = 0.0;
      size[i]    = input->GetDimension(i);
      spacing[i] = 1.0;
   }
 
   // build region from size
   IndexType start;
   start.Fill( 0 );
   RegionType region;
   region.SetIndex( start );
   region.SetSize(  size  );
 
   // copy as much information as possible into origin
   const mitk::Point3D& mitkorigin = input->GetGeometry()->GetOrigin();
   itk2vtk(mitkorigin, origin);
 
   // copy as much information as possible into direction
   direction.SetIdentity();
   unsigned int j;
   const AffineTransform3D::MatrixType& matrix = input->GetGeometry()->GetIndexToWorldTransform()->GetMatrix();
 
   /// \warning 2D MITK images could have a 3D rotation, since they have a 3x3 geometry matrix.
   /// If it is only a rotation around the axial plane normal, it can be express with a 2x2 matrix.
   /// In this case, the ITK image conservs this information and is identical to the MITK image!
   /// If the MITK image contains any other rotation, the ITK image will have no rotation at all.
   /// Spacing is of course conserved in both cases.
 
 
   // the following loop devides by spacing now to normalize columns.
   // counterpart of InitializeByItk in mitkImage.h line 372 of revision 15092.
 
   // Check if information is lost
   if (  TOutputImage::ImageDimension <= 2)
   {
      if (( TOutputImage::ImageDimension == 2) && (
            ( matrix[0][2] != 0) ||
            ( matrix[1][2] != 0) ||
            ( matrix[2][0] != 0) ||
            ( matrix[2][1] != 0) ||
            (( matrix[2][2] != 1) &&  ( matrix[2][2] != -1) )))
      {
         // The 2D MITK image contains 3D rotation information.
         // This cannot be expressed in a 2D ITK image, so the ITK image will have no rotation
 
      }
      else
      {
         // The 2D MITK image can be converted to an 2D ITK image without information loss!
         for ( i=0; i < itkDimMax3; ++i)
            for( j=0; j < itkDimMax3; ++j )
               direction[i][j] = matrix[i][j]/spacing[j];
      }
   }
   else
   {
      // Normal 3D image. Conversion possible without problem!
      for ( i=0; i < itkDimMax3; ++i)
         for( j=0; j < itkDimMax3; ++j )
            direction[i][j] = matrix[i][j]/spacing[j];
   }
 
   // set information into output image
   output->SetRegions( region );
   output->SetOrigin( origin );
   output->SetSpacing( spacing );
   output->SetDirection( direction );
 }
 
 template<class TOutputImage>
   void
   mitk::ImageToItk<TOutputImage>
   ::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os,indent);
 }
 
 #endif //IMAGETOITK_TXX_INCLUDED_C1C2FCD2
diff --git a/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp b/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
index 439780cafc..c83f37ee82 100644
--- a/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
+++ b/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
@@ -1,83 +1,82 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkLandmarkProjectorBasedCurvedGeometry.h"
 #include <vtkAbstractTransform.h>
 
 mitk::LandmarkProjectorBasedCurvedGeometry::LandmarkProjectorBasedCurvedGeometry()
   : m_LandmarkProjector(NULL), m_InterpolatingAbstractTransform(NULL)
 {
 }
 
 mitk::LandmarkProjectorBasedCurvedGeometry::LandmarkProjectorBasedCurvedGeometry(const mitk::LandmarkProjectorBasedCurvedGeometry& other) : Superclass(other)
 {
   this->SetLandmarkProjector(other.m_LandmarkProjector);
   this->ComputeGeometry();
 }
 
 mitk::LandmarkProjectorBasedCurvedGeometry::~LandmarkProjectorBasedCurvedGeometry()
 {
   if(m_InterpolatingAbstractTransform!=NULL)
     m_InterpolatingAbstractTransform->Delete();
 }
 
 void mitk::LandmarkProjectorBasedCurvedGeometry::SetLandmarkProjector(mitk::LandmarkProjector* aLandmarkProjector)
 {
   itkDebugMacro("setting LandmarkProjector to " << aLandmarkProjector );
   if(m_LandmarkProjector != aLandmarkProjector)
   {
     m_LandmarkProjector = aLandmarkProjector;
     if(m_LandmarkProjector.IsNotNull())
     {
       if(m_FrameGeometry.IsNotNull())
         m_LandmarkProjector->SetFrameGeometry(m_FrameGeometry);
 
       if(m_InterpolatingAbstractTransform == NULL)
       {
         itkWarningMacro(<<"m_InterpolatingAbstractTransform not set.");
       }
       m_LandmarkProjector->SetInterpolatingAbstractTransform(GetInterpolatingAbstractTransform());
 
       SetVtkAbstractTransform(m_LandmarkProjector->GetCompleteAbstractTransform());
     }
     Modified();
   }
 }
 
 void mitk::LandmarkProjectorBasedCurvedGeometry::SetFrameGeometry(const mitk::Geometry3D* frameGeometry)
 {
   Superclass::SetFrameGeometry(frameGeometry);
   if(m_LandmarkProjector.IsNotNull())
     m_LandmarkProjector->SetFrameGeometry(frameGeometry);
 }
 
 void mitk::LandmarkProjectorBasedCurvedGeometry::ComputeGeometry()
 {
   if(m_LandmarkProjector.IsNull())
   {
     itkExceptionMacro(<< "m_LandmarkProjector is not set.");
   }
   m_LandmarkProjector->ProjectLandmarks(m_TargetLandmarks);
   SetPlane(m_LandmarkProjector->GetParameterPlane());
 }
-
 itk::LightObject::Pointer mitk::LandmarkProjectorBasedCurvedGeometry::InternalClone() const
 {
-  itk::LightObject::Pointer newGeometry = new LandmarkProjectorBasedCurvedGeometry(*this);
+  mitk::Geometry3D::Pointer newGeometry = new LandmarkProjectorBasedCurvedGeometry(*this);
   newGeometry->UnRegister();
   return newGeometry.GetPointer();
 }
diff --git a/Core/Code/DataManagement/mitkPointSet.cpp b/Core/Code/DataManagement/mitkPointSet.cpp
index 6f3bf1fdf1..8c6d772f72 100755
--- a/Core/Code/DataManagement/mitkPointSet.cpp
+++ b/Core/Code/DataManagement/mitkPointSet.cpp
@@ -1,885 +1,884 @@
 /*===================================================================
 
 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 "mitkPointSet.h"
 #include "mitkPointOperation.h"
 #include "mitkInteractionConst.h"
 
 #include <mitkTesting.h>
 #include <iomanip>
 
 mitk::PointSet::PointSet()
 {
   this->InitializeEmpty();
 }
 
 mitk::PointSet::PointSet(const PointSet &other)
   : BaseData(other)
   , m_PointSetSeries(other.GetPointSetSeriesSize())
   , m_CalculateBoundingBox(true)
 {
 
    // Copy points
    for (std::size_t t = 0; t < m_PointSetSeries.size(); ++t)
    {
      m_PointSetSeries[t] = DataType::New();
 
      DataType::Pointer otherPts = other.GetPointSet(t);
      for (PointsConstIterator i = other.Begin(t);
           i != other.End(t); ++i)
       {
        m_PointSetSeries[t]->SetPoint(i.Index(), i.Value());
        PointDataType pointData;
        if (otherPts->GetPointData(i.Index(), &pointData))
        {
          m_PointSetSeries[t]->SetPointData(i.Index(), pointData);
        }
       }
    }
 }
 
 mitk::PointSet::~PointSet()
 {
   this->ClearData();
 }
 
 void mitk::PointSet::ClearData()
 {
   m_PointSetSeries.clear();
   Superclass::ClearData();
 }
 
 void mitk::PointSet::InitializeEmpty()
 {
   m_PointSetSeries.resize( 1 );
 
   m_PointSetSeries[0] = DataType::New();
   PointDataContainer::Pointer pointData = PointDataContainer::New();
   m_PointSetSeries[0]->SetPointData( pointData );
   m_CalculateBoundingBox = false;
 
-  Superclass::InitializeTimeSlicedGeometry(1);
+  Superclass::InitializeTimeGeometry(1);
   m_Initialized = true;
 }
 
 bool mitk::PointSet::IsEmptyTimeStep(unsigned int t) const
 {
   return IsInitialized() && (GetSize(t) == 0);
 }
 
 void mitk::PointSet::Expand( unsigned int timeSteps )
 {
   // Check if the vector is long enough to contain the new element
   // at the given position. If not, expand it with sufficient pre-initialized
   // elements.
   //
   // NOTE: This method will never REDUCE the vector size; it should only
   // be used to make sure that the vector has enough elements to include the
   // specified time step.
 
   unsigned int oldSize = m_PointSetSeries.size();
 
   if ( timeSteps > oldSize )
   {
     Superclass::Expand( timeSteps );
 
     m_PointSetSeries.resize( timeSteps );
     for ( unsigned int i = oldSize; i < timeSteps; ++i )
     {
       m_PointSetSeries[i] = DataType::New();
       PointDataContainer::Pointer pointData = PointDataContainer::New();
       m_PointSetSeries[i]->SetPointData( pointData );
     }
 
     //if the size changes, then compute the bounding box
     m_CalculateBoundingBox = true;
 
     this->InvokeEvent( PointSetExtendTimeRangeEvent() );
   }
 }
 
 
 unsigned int mitk::PointSet::GetPointSetSeriesSize() const
 {
   return m_PointSetSeries.size();
 }
 
 
 int mitk::PointSet::GetSize( unsigned int t ) const
 {
   if ( t < m_PointSetSeries.size() )
   {
     return m_PointSetSeries[t]->GetNumberOfPoints();
   }
   else
   {
     return 0;
   }
 }
 
 mitk::PointSet::DataType::Pointer mitk::PointSet::GetPointSet( int t ) const
 {
   if ( t < (int)m_PointSetSeries.size() )
   {
     return m_PointSetSeries[t];
   }
   else
   {
     return NULL;
   }
 }
 
 mitk::PointSet::PointsIterator mitk::PointSet::Begin( int t )
 {
   if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
   {
     return m_PointSetSeries[t]->GetPoints()->Begin();
   }
   return PointsIterator();
 }
 
 mitk::PointSet::PointsConstIterator mitk::PointSet::Begin(int t) const
 {
   if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
   {
     return m_PointSetSeries[t]->GetPoints()->Begin();
   }
   return PointsConstIterator();
 }
 
 mitk::PointSet::PointsIterator mitk::PointSet::End( int t )
 {
   if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
   {
     return m_PointSetSeries[t]->GetPoints()->End();
   }
   return PointsIterator();
 }
 
 mitk::PointSet::PointsConstIterator mitk::PointSet::End(int t) const
 {
   if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
   {
     return m_PointSetSeries[t]->GetPoints()->End();
   }
   return PointsConstIterator();
 }
 
 int mitk::PointSet::SearchPoint( Point3D point, float distance, int t  ) const
 {
   if ( t >= (int)m_PointSetSeries.size() )
   {
     return -1;
   }
 
   // Out is the point which is checked to be the searched point
   PointType out;
   out.Fill( 0 );
   PointType indexPoint;
 
   this->GetGeometry( t )->WorldToIndex(point, indexPoint);
 
   // Searching the first point in the Set, that is +- distance far away fro
   // the given point
   unsigned int i;
   PointsContainer::Iterator it, end;
   end = m_PointSetSeries[t]->GetPoints()->End();
   int bestIndex = -1;
   distance = distance * distance;
 
   // To correct errors from converting index to world and world to index
   if (distance == 0.0)
   {
     distance = 0.000001;
   }
 
   ScalarType bestDist = distance;
   ScalarType dist, tmp;
 
   for ( it = m_PointSetSeries[t]->GetPoints()->Begin(), i = 0;
         it != end;
         ++it, ++i )
   {
     bool ok = m_PointSetSeries[t]->GetPoints()
       ->GetElementIfIndexExists( it->Index(), &out );
 
     if ( !ok )
     {
       return -1;
     }
     else if ( indexPoint == out ) //if totally equal
     {
       return it->Index();
     }
 
     //distance calculation
     tmp = out[0] - indexPoint[0]; dist  = tmp * tmp;
     tmp = out[1] - indexPoint[1]; dist += tmp * tmp;
     tmp = out[2] - indexPoint[2]; dist += tmp * tmp;
 
     if ( dist < bestDist )
     {
       bestIndex = it->Index();
       bestDist  = dist;
     }
   }
   return bestIndex;
 }
 
 mitk::PointSet::PointType
 mitk::PointSet::GetPoint( PointIdentifier id, int t ) const
 {
   PointType out;
   out.Fill(0);
 
   if ( (unsigned int) t >= m_PointSetSeries.size() )
   {
     return out;
   }
 
   if ( m_PointSetSeries[t]->GetPoints()->IndexExists(id) )
   {
     m_PointSetSeries[t]->GetPoint( id, &out );
     this->GetGeometry(t)->IndexToWorld( out, out );
     return out;
   }
   else
   {
     return out;
   }
 }
 
 
 bool
 mitk::PointSet
 ::GetPointIfExists( PointIdentifier id, PointType* point, int t ) const
 {
   if ( (unsigned int) t >= m_PointSetSeries.size() )
   {
     return false;
   }
 
   if ( m_PointSetSeries[t]->GetPoints()->GetElementIfIndexExists(id, point) )
   {
     this->GetGeometry( t )->IndexToWorld( *point, *point );
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, int t )
 {
   // Adapt the size of the data vector if necessary
   this->Expand( t+1 );
 
   mitk::Point3D indexPoint;
   this->GetGeometry( t )->WorldToIndex( point, indexPoint );
   m_PointSetSeries[t]->SetPoint( id, indexPoint );
   PointDataType defaultPointData;
   defaultPointData.id = id;
   defaultPointData.selected = false;
   defaultPointData.pointSpec = mitk::PTUNDEFINED;
 
   m_PointSetSeries[t]->SetPointData( id, defaultPointData );
   //boundingbox has to be computed anyway
   m_CalculateBoundingBox = true;
   this->Modified();
 }
 
 
 void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
 {
   // Adapt the size of the data vector if necessary
   this->Expand( t+1 );
 
   mitk::Point3D indexPoint;
   this->GetGeometry( t )->WorldToIndex( point, indexPoint );
   m_PointSetSeries[t]->SetPoint( id, indexPoint );
   PointDataType defaultPointData;
   defaultPointData.id = id;
   defaultPointData.selected = false;
   defaultPointData.pointSpec = spec;
   m_PointSetSeries[t]->SetPointData( id, defaultPointData );
   //boundingbox has to be computed anyway
   m_CalculateBoundingBox = true;
   this->Modified();
 }
 
 
 void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, int t )
 {
   this->InsertPoint(id, point, mitk::PTUNDEFINED, t);
 }
 
 
 void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
 {
   if ( (unsigned int) t < m_PointSetSeries.size() )
   {
     mitk::Point3D indexPoint;
     mitk::Geometry3D* tempGeometry = this->GetGeometry( t );
     if (tempGeometry == NULL)
     {
       MITK_INFO<< __FILE__ << ", l." << __LINE__ << ": GetGeometry of "<< t <<" returned NULL!" << std::endl;
       return;
     }
     tempGeometry->WorldToIndex( point, indexPoint );
     m_PointSetSeries[t]->GetPoints()->InsertElement( id, indexPoint );
     PointDataType defaultPointData;
     defaultPointData.id = id;
     defaultPointData.selected = false;
     defaultPointData.pointSpec = spec;
     m_PointSetSeries[t]->GetPointData()->InsertElement(id, defaultPointData);
 
     //boundingbox has to be computed anyway
     m_CalculateBoundingBox = true;
     this->Modified();
   }
 }
 
 
 bool mitk::PointSet::SwapPointPosition( PointIdentifier id, bool moveUpwards, int t )
 {
   if(IndexExists(id, t) )
   {
     PointType point = GetPoint(id,t);
 
     if(moveUpwards)
     {//up
       if(IndexExists(id-1,t))
       {
         InsertPoint(id, GetPoint(id - 1, t), t);
         InsertPoint(id-1,point,t);
         this->Modified();
         return true;
       }
     }
     else
     {//down
       if(IndexExists(id+1,t))
       {
         InsertPoint(id, GetPoint(id + 1, t), t);
         InsertPoint(id+1,point,t);
         this->Modified();
         return true;
       }
     }
   }
   return false;
 }
 
 bool mitk::PointSet::IndexExists( int position, int t ) const
 {
   if ( (unsigned int) t < m_PointSetSeries.size() )
   {
     return m_PointSetSeries[t]->GetPoints()->IndexExists( position );
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::PointSet::GetSelectInfo( int position, int t ) const
 {
   if ( this->IndexExists( position, t ) )
   {
     PointDataType pointData = { 0, false, PTUNDEFINED };
     m_PointSetSeries[t]->GetPointData( position, &pointData );
     return pointData.selected;
   }
   else
   {
     return false;
   }
 }
 
 
 void mitk::PointSet::SetSelectInfo( int position, bool selected, int t )
 {
   if ( this->IndexExists( position, t ) )
   {
     // timeStep to ms
-    ScalarType timeInMS = this->GetTimeSlicedGeometry()->TimeStepToMS( t );
+    TimePointType timeInMS = this->GetTimeGeometry()->TimeStepToTimePoint( t );
 
     // point
     Point3D point = this->GetPoint( position, t );
 
     std::auto_ptr<PointOperation> op;
     if (selected)
     {
       op.reset(new mitk::PointOperation(OpSELECTPOINT, timeInMS, point, position ));
     }
     else
     {
       op.reset(new mitk::PointOperation(OpDESELECTPOINT, timeInMS, point, position ));
     }
 
     this->ExecuteOperation( op.get() );
   }
 }
 
 mitk::PointSpecificationType mitk::PointSet::GetSpecificationTypeInfo( int position, int t ) const
 {
   if ( this->IndexExists( position, t ) )
   {
     PointDataType pointData = { 0, false, PTUNDEFINED };
     m_PointSetSeries[t]->GetPointData( position, &pointData );
     return pointData.pointSpec;
   }
   else
   {
     return PTUNDEFINED;
   }
 }
 
 int mitk::PointSet::GetNumberOfSelected( int t ) const
 {
   if ( (unsigned int) t >= m_PointSetSeries.size() )
   {
     return 0;
   }
 
   int numberOfSelected = 0;
   PointDataIterator it;
   for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
         it != m_PointSetSeries[t]->GetPointData()->End();
         it++ )
   {
     if (it->Value().selected == true)
     {
       ++numberOfSelected;
     }
   }
 
   return numberOfSelected;
 }
 
 
 int mitk::PointSet::SearchSelectedPoint( int t ) const
 {
   if ( (unsigned int) t >= m_PointSetSeries.size() )
   {
     return -1;
   }
 
   PointDataIterator it;
   for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
         it != m_PointSetSeries[t]->GetPointData()->End();
         it++ )
   {
     if ( it->Value().selected == true )
     {
       return it->Index();
     }
   }
   return -1;
 }
 
 void mitk::PointSet::ExecuteOperation( Operation* operation )
 {
   int timeStep = -1;
 
   mitkCheckOperationTypeMacro(PointOperation, operation, pointOp);
 
   if ( pointOp )
   {
-    timeStep = this->GetTimeSlicedGeometry()
-      ->MSToTimeStep( pointOp->GetTimeInMS() );
+    timeStep = this->GetTimeGeometry()->TimePointToTimeStep( pointOp->GetTimeInMS() );
   }
 
   if ( timeStep < 0 )
   {
     MITK_ERROR << "Time step (" << timeStep << ") outside of PointSet time bounds" << std::endl;
     return;
   }
 
   switch (operation->GetOperationType())
   {
   case OpNOTHING:
     break;
 
   case OpINSERT://inserts the point at the given position and selects it.
     {
       int position = pointOp->GetIndex();
 
       PointType pt;
       pt.CastFrom(pointOp->GetPoint());
 
       //transfer from world to index coordinates
       mitk::Geometry3D* geometry = this->GetGeometry( timeStep );
       if (geometry == NULL)
       {
         MITK_INFO<<"GetGeometry returned NULL!\n";
         return;
       }
       geometry->WorldToIndex(pt, pt);
 
       m_PointSetSeries[timeStep]->GetPoints()->InsertElement(position, pt);
 
       PointDataType pointData =
       {
         static_cast<unsigned int>(pointOp->GetIndex()),
         pointOp->GetSelected(),
         pointOp->GetPointType()
       };
 
       m_PointSetSeries[timeStep]->GetPointData()
         ->InsertElement(position, pointData);
 
       this->Modified();
 
       //boundingbox has to be computed
       m_CalculateBoundingBox = true;
 
       this->InvokeEvent( PointSetAddEvent() );
       this->OnPointSetChange();
     }
     break;
 
   case OpMOVE://moves the point given by index
     {
       PointType pt;
       pt.CastFrom(pointOp->GetPoint());
 
       //transfer from world to index coordinates
       this->GetGeometry( timeStep )->WorldToIndex(pt, pt);
 
       // Copy new point into container
       m_PointSetSeries[timeStep]->SetPoint(pointOp->GetIndex(), pt);
 
       // Insert a default point data object to keep the containers in sync
       // (if no point data object exists yet)
       PointDataType pointData;
       if ( !m_PointSetSeries[timeStep]->GetPointData( pointOp->GetIndex(), &pointData ) )
       {
         m_PointSetSeries[timeStep]->SetPointData( pointOp->GetIndex(), pointData );
       }
 
       this->OnPointSetChange();
 
       this->Modified();
 
       //boundingbox has to be computed anyway
       m_CalculateBoundingBox = true;
 
       this->InvokeEvent( PointSetMoveEvent() );
     }
     break;
 
   case OpREMOVE://removes the point at given by position
     {
       m_PointSetSeries[timeStep]->GetPoints()->DeleteIndex((unsigned)pointOp->GetIndex());
       m_PointSetSeries[timeStep]->GetPointData()->DeleteIndex((unsigned)pointOp->GetIndex());
 
       this->OnPointSetChange();
 
       this->Modified();
       //boundingbox has to be computed anyway
       m_CalculateBoundingBox = true;
 
       this->InvokeEvent( PointSetRemoveEvent() );
     }
     break;
 
   case OpSELECTPOINT://select the given point
     {
       PointDataType pointData = {0, false, PTUNDEFINED};
       m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
       pointData.selected = true;
       m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
       this->Modified();
     }
     break;
 
   case OpDESELECTPOINT://unselect the given point
     {
       PointDataType pointData = {0, false, PTUNDEFINED};
       m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
       pointData.selected = false;
       m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
       this->Modified();
     }
     break;
 
   case OpSETPOINTTYPE:
     {
       PointDataType pointData = {0, false, PTUNDEFINED};
       m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
       pointData.pointSpec = pointOp->GetPointType();
       m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
       this->Modified();
     }
     break;
 
   case OpMOVEPOINTUP: // swap content of point with ID pointOp->GetIndex() with the point preceding it in the container // move point position within the pointset
     {
       PointIdentifier currentID = pointOp->GetIndex();
       /* search for point with this id and point that precedes this one in the data container */
       PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
       PointsContainer::STLContainerType::iterator it = points.find(currentID);
       if (it == points.end()) // ID not found
         break;
       if (it == points.begin()) // we are at the first element, there is no previous element
         break;
 
       /* get and cache current point & pointdata and previous point & pointdata */
       --it;
       PointIdentifier prevID = it->first;
       if (this->SwapPointContents(prevID, currentID, timeStep) == true)
         this->Modified();
     }
     break;
   case OpMOVEPOINTDOWN: // move point position within the pointset
     {
       PointIdentifier currentID = pointOp->GetIndex();
       /* search for point with this id and point that succeeds this one in the data container */
       PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
       PointsContainer::STLContainerType::iterator it = points.find(currentID);
       if (it == points.end()) // ID not found
         break;
       ++it;
       if (it == points.end()) // ID is already the last element, there is no succeeding element
         break;
 
       /* get and cache current point & pointdata and previous point & pointdata */
       PointIdentifier nextID = it->first;
       if (this->SwapPointContents(nextID, currentID, timeStep) == true)
         this->Modified();
     }
     break;
 
   default:
     itkWarningMacro("mitkPointSet could not understrand the operation. Please check!");
     break;
   }
 
   //to tell the mappers, that the data is modified and has to be updated
   //only call modified if anything is done, so call in cases
   //this->Modified();
 
   mitk::OperationEndEvent endevent(operation);
   ((const itk::Object*)this)->InvokeEvent(endevent);
 
   //*todo has to be done here, cause of update-pipeline not working yet
   // As discussed lately, don't mess with the rendering from inside data structures
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void mitk::PointSet::UpdateOutputInformation()
 {
   if ( this->GetSource( ) )
   {
       this->GetSource( )->UpdateOutputInformation( );
   }
 
   //
   // first make sure, that the associated time sliced geometry has
   // the same number of geometry 3d's as PointSets are present
   //
-  mitk::TimeSlicedGeometry* timeGeometry = GetTimeSlicedGeometry();
-  if ( timeGeometry->GetTimeSteps() != m_PointSetSeries.size() )
+  TimeGeometry* timeGeometry = GetTimeGeometry();
+  if ( timeGeometry->GetNumberOfTimeSteps() != m_PointSetSeries.size() )
   {
-    itkExceptionMacro(<<"timeGeometry->GetTimeSteps() != m_PointSetSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
+    itkExceptionMacro(<<"timeGeometry->GetNumberOfTimeSteps() != m_PointSetSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
   }
 
   // This is needed to detect zero objects
   mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
   BoundingBox::BoundsArrayType itkBoundsNull(nullpoint);
 
   //
   // Iterate over the PointSets and update the Geometry
   // information of each of the items.
   //
   if (m_CalculateBoundingBox)
   {
     for ( unsigned int i = 0 ; i < m_PointSetSeries.size() ; ++i )
     {
       const DataType::BoundingBoxType *bb = m_PointSetSeries[i]->GetBoundingBox();
       BoundingBox::BoundsArrayType itkBounds = bb->GetBounds();
 
       if ( m_PointSetSeries[i].IsNull() || (m_PointSetSeries[i]->GetNumberOfPoints() == 0)
         || (itkBounds == itkBoundsNull) )
       {
         itkBounds = itkBoundsNull;
         continue;
       }
 
       // Ensure minimal bounds of 1.0 in each dimension
       for ( unsigned int j = 0; j < 3; ++j )
       {
         if ( itkBounds[j*2+1] - itkBounds[j*2] < 1.0 )
         {
           BoundingBox::CoordRepType center =
             (itkBounds[j*2] + itkBounds[j*2+1]) / 2.0;
           itkBounds[j*2] = center - 0.5;
           itkBounds[j*2+1] = center + 0.5;
         }
       }
       this->GetGeometry(i)->SetBounds(itkBounds);
     }
     m_CalculateBoundingBox = false;
   }
-  this->GetTimeSlicedGeometry()->UpdateInformation();
+  this->GetTimeGeometry()->Update();
 }
 
 void mitk::PointSet::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 bool mitk::PointSet::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
 
 bool mitk::PointSet::VerifyRequestedRegion()
 {
     return true;
 }
 
 void mitk::PointSet::SetRequestedRegion(const DataObject * )
 {
 }
 
 
 void mitk::PointSet::PrintSelf( std::ostream& os, itk::Indent indent ) const
 {
   Superclass::PrintSelf(os, indent);
 
   os << indent << "Number timesteps: " << m_PointSetSeries.size() << "\n";
   unsigned int i = 0;
   for (PointSetSeries::const_iterator it = m_PointSetSeries.begin(); it != m_PointSetSeries.end(); ++it)
   {
     os << indent << "Timestep " << i++ << ": \n";
     MeshType::Pointer ps = *it;
     itk::Indent nextIndent = indent.GetNextIndent();
     ps->Print(os, nextIndent);
     MeshType::PointsContainer* points = ps->GetPoints();
     MeshType::PointDataContainer* datas = ps->GetPointData();
     MeshType::PointDataContainer::Iterator dataIterator = datas->Begin();
     for (MeshType::PointsContainer::Iterator pointIterator = points->Begin();
       pointIterator != points->End();
       ++pointIterator, ++dataIterator)
     {
       os << nextIndent << "Point " << pointIterator->Index() << ": [";
       os << pointIterator->Value().GetElement(0);
       for (unsigned int i = 1; i < PointType::GetPointDimension(); ++i)
       {
         os << ", " << pointIterator->Value().GetElement(i);
       }
       os << "]";
       os << ", selected: " << dataIterator->Value().selected << ", point spec: " << dataIterator->Value().pointSpec << "\n";
     }
   }
 }
 
 bool mitk::PointSet::SwapPointContents(PointIdentifier id1, PointIdentifier id2, int timeStep)
 {
   /* search and cache contents */
   PointType p1;
   if (m_PointSetSeries[timeStep]->GetPoint(id1, &p1) == false)
     return false;
   PointDataType data1;
   if (m_PointSetSeries[timeStep]->GetPointData(id1, &data1) == false)
     return false;
   PointType p2;
   if (m_PointSetSeries[timeStep]->GetPoint(id2, &p2) == false)
     return false;
   PointDataType data2;
   if (m_PointSetSeries[timeStep]->GetPointData(id2, &data2) == false)
     return false;
   /* now swap contents */
   m_PointSetSeries[timeStep]->SetPoint(id1, p2);
   m_PointSetSeries[timeStep]->SetPointData(id1, data2);
   m_PointSetSeries[timeStep]->SetPoint(id2, p1);
   m_PointSetSeries[timeStep]->SetPointData(id2, data1);
   return true;
 }
 
 bool mitk::PointSet::PointDataType::operator ==(const mitk::PointSet::PointDataType &other) const
 {
   return id == other.id && selected == other.selected && pointSpec == other.pointSpec;
 }
 
 bool mitk::Equal( const mitk::PointSet* leftHandSide, const mitk::PointSet* rightHandSide, mitk::ScalarType eps, bool verbose )
 {
   bool result = true;
 
   if( rightHandSide == NULL )
   {
     if(verbose)
     {
       MITK_INFO << "[( PointSet )] rightHandSide NULL.";
     }
     return false;
   }
   if( leftHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[( PointSet )] leftHandSide NULL.";
     return false;
   }
 
   if( !mitk::Equal(leftHandSide->GetGeometry(), rightHandSide->GetGeometry(), eps, verbose) )
   {
     if(verbose)
       MITK_INFO << "[( PointSet )] Geometries differ.";
     result = false;
   }
 
   if ( leftHandSide->GetSize() != rightHandSide->GetSize())
   {
     if(verbose)
       MITK_INFO << "[( PointSet )] Number of points differ.";
     result = false;
   }
   else
   {
     //if the size is equal, we compare the point values
     mitk::Point3D pointLeftHandSide;
     mitk::Point3D pointRightHandSide;
 
     int numberOfIncorrectPoints = 0;
 
     //Iterate over both pointsets in order to compare all points pair-wise
     mitk::PointSet::PointsConstIterator end = leftHandSide->End();
     for( mitk::PointSet::PointsConstIterator pointSetIteratorLeft = leftHandSide->Begin(), pointSetIteratorRight = rightHandSide->Begin();
          pointSetIteratorLeft != end; ++pointSetIteratorLeft, ++pointSetIteratorRight) //iterate simultaneously over both sets
     {
       pointLeftHandSide = pointSetIteratorLeft.Value();
       pointRightHandSide = pointSetIteratorRight.Value();
       if( !mitk::Equal( pointLeftHandSide, pointRightHandSide, eps, verbose ) )
       {
         if(verbose)
           MITK_INFO << "[( PointSet )] Point values are different.";
         result = false;
         numberOfIncorrectPoints++;
       }
     }
 
     if((numberOfIncorrectPoints > 0) && verbose)
     {
       MITK_INFO << numberOfIncorrectPoints <<" of a total of " << leftHandSide->GetSize() << " points are different.";
     }
   }
   return result;
 }
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
new file mode 100644
index 0000000000..d5ea54e0d1
--- /dev/null
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
@@ -0,0 +1,223 @@
+/*===================================================================
+
+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 <mitkProportionalTimeGeometry.h>
+#include <limits>
+
+mitk::ProportionalTimeGeometry::ProportionalTimeGeometry() :
+  m_FirstTimePoint(0.0),
+  m_StepDuration(1.0)
+{
+}
+
+mitk::ProportionalTimeGeometry::~ProportionalTimeGeometry()
+{
+}
+
+void mitk::ProportionalTimeGeometry::Initialize()
+{
+  m_FirstTimePoint = 0.0;
+  m_StepDuration = 1.0;
+}
+
+mitk::TimeStepType mitk::ProportionalTimeGeometry::GetNumberOfTimeSteps () const
+{
+  return static_cast<TimeStepType>(m_GeometryVector.size() );
+}
+
+mitk::TimePointType mitk::ProportionalTimeGeometry::GetMinimumTimePoint () const
+{
+  return m_FirstTimePoint;
+}
+
+mitk::TimePointType mitk::ProportionalTimeGeometry::GetMaximumTimePoint () const
+{
+  TimePointType timePoint = m_FirstTimePoint + m_StepDuration * GetNumberOfTimeSteps();
+  if (timePoint >std::numeric_limits<TimePointType>().max())
+    timePoint = std::numeric_limits<TimePointType>().max();
+  return timePoint;
+}
+
+mitk::TimeBounds mitk::ProportionalTimeGeometry::GetTimeBounds () const
+{
+  TimeBounds bounds;
+  bounds[0] = this->GetMinimumTimePoint();
+  bounds[1] = this->GetMaximumTimePoint();
+  return bounds;
+}
+
+bool mitk::ProportionalTimeGeometry::IsValidTimePoint (TimePointType timePoint) const
+{
+  return this->GetMinimumTimePoint() <= timePoint && timePoint < this->GetMaximumTimePoint();
+}
+
+bool mitk::ProportionalTimeGeometry::IsValidTimeStep (TimeStepType timeStep) const
+{
+  return 0 <= timeStep && timeStep <  this->GetNumberOfTimeSteps();
+}
+
+mitk::TimePointType mitk::ProportionalTimeGeometry::TimeStepToTimePoint( TimeStepType timeStep) const
+{
+  if (m_FirstTimePoint <= std::numeric_limits<TimePointType>::min() ||
+      m_FirstTimePoint >= std::numeric_limits<TimePointType>::max() ||
+      m_StepDuration <= std::numeric_limits<TimePointType>::min() ||
+      m_StepDuration >= std::numeric_limits<TimePointType>::max())
+  {
+    return static_cast<TimePointType>(timeStep);
+  }
+
+  return m_FirstTimePoint + timeStep * m_StepDuration;
+}
+
+mitk::TimeStepType mitk::ProportionalTimeGeometry::TimePointToTimeStep( TimePointType timePoint) const
+{
+  if (m_FirstTimePoint <= timePoint)
+    return static_cast<TimeStepType>((timePoint -m_FirstTimePoint) / m_StepDuration);
+  else
+    return 0;
+}
+
+mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryForTimeStep( TimeStepType timeStep) const
+{
+  if (IsValidTimeStep(timeStep))
+  {
+    return dynamic_cast<Geometry3D*>(m_GeometryVector[timeStep].GetPointer());
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryForTimePoint(TimePointType timePoint) const
+{
+  if (this->IsValidTimePoint(timePoint))
+  {
+    TimeStepType timeStep = this->TimePointToTimeStep(timePoint);
+    return this->GetGeometryForTimeStep(timeStep);
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+
+mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryCloneForTimeStep( TimeStepType timeStep) const
+{
+  if (timeStep > m_GeometryVector.size())
+    return 0;
+  return m_GeometryVector[timeStep]->Clone();
+}
+
+bool mitk::ProportionalTimeGeometry::IsValid() const
+{
+  bool isValid = true;
+  isValid &= m_GeometryVector.size() > 0;
+  isValid &= m_StepDuration > 0;
+  return isValid;
+}
+
+void mitk::ProportionalTimeGeometry::ClearAllGeometries()
+{
+  m_GeometryVector.clear();
+}
+
+void mitk::ProportionalTimeGeometry::ReserveSpaceForGeometries(TimeStepType numberOfGeometries)
+{
+  m_GeometryVector.reserve(numberOfGeometries);
+}
+
+void mitk::ProportionalTimeGeometry::Expand(mitk::TimeStepType size)
+{
+  m_GeometryVector.reserve(size);
+  while  (m_GeometryVector.size() < size)
+  {
+    m_GeometryVector.push_back(Geometry3D::New());
+  }
+}
+
+void mitk::ProportionalTimeGeometry::SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep)
+{
+  assert(timeStep<=m_GeometryVector.size());
+  assert(timeStep >= 0);
+
+  if (timeStep == m_GeometryVector.size())
+    m_GeometryVector.push_back(geometry);
+
+  m_GeometryVector[timeStep] = geometry;
+}
+
+itk::LightObject::Pointer mitk::ProportionalTimeGeometry::InternalClone() const
+{
+  itk::LightObject::Pointer parent = Superclass::InternalClone();
+  ProportionalTimeGeometry::Pointer newTimeGeometry =
+    dynamic_cast<ProportionalTimeGeometry * > (parent.GetPointer());
+  newTimeGeometry->m_FirstTimePoint = this->m_FirstTimePoint;
+  newTimeGeometry->m_StepDuration = this->m_StepDuration;
+  newTimeGeometry->m_GeometryVector.clear();
+  newTimeGeometry->Expand(this->GetNumberOfTimeSteps());
+  for (TimeStepType i =0; i < GetNumberOfTimeSteps(); ++i)
+  {
+    Geometry3D::Pointer tempGeometry = GetGeometryForTimeStep(i)->Clone();
+    newTimeGeometry->SetTimeStepGeometry(tempGeometry.GetPointer(),i);
+  }
+  return parent;
+}
+
+void mitk::ProportionalTimeGeometry::Initialize (Geometry3D* geometry, TimeStepType timeSteps)
+{
+  timeSteps = (timeSteps > 0) ? timeSteps : 1;
+  m_FirstTimePoint = geometry->GetTimeBounds()[0];
+  m_StepDuration = geometry->GetTimeBounds()[1] - geometry->GetTimeBounds()[0];
+  this->ReserveSpaceForGeometries(timeSteps);
+  try{
+  for (TimeStepType currentStep = 0; currentStep < timeSteps; ++currentStep)
+  {
+    mitk::TimeBounds timeBounds;
+    if (timeSteps > 1)
+    {
+      timeBounds[0] = m_FirstTimePoint + currentStep * m_StepDuration;
+      timeBounds[1] = m_FirstTimePoint + (currentStep+1) * m_StepDuration;
+    }
+    else
+    {
+      timeBounds = geometry->GetTimeBounds();
+    }
+
+    Geometry3D::Pointer clonedGeometry = geometry->Clone();
+    this->SetTimeStepGeometry(clonedGeometry.GetPointer(), currentStep);
+    GetGeometryForTimeStep(currentStep)->SetTimeBounds(timeBounds);
+  }
+  }
+  catch (...)
+  {
+    MITK_INFO << "Cloning of geometry produced an error!";
+  }
+  Update();
+}
+
+void mitk::ProportionalTimeGeometry::Initialize (TimeStepType timeSteps)
+{
+  mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
+  geometry->Initialize();
+
+  if ( timeSteps > 1 )
+  {
+    mitk::ScalarType timeBounds[] = {0.0, 1.0};
+    geometry->SetTimeBounds( timeBounds );
+  }
+  this->Initialize(geometry.GetPointer(), timeSteps);
+}
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.h b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
new file mode 100644
index 0000000000..ce2b96e28f
--- /dev/null
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
@@ -0,0 +1,204 @@
+/*===================================================================
+
+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 ProportionalTimeGeometry_h
+#define ProportionalTimeGeometry_h
+
+//MITK
+#include <mitkTimeGeometry.h>
+#include <mitkCommon.h>
+#include <MitkExports.h>
+
+namespace mitk {
+
+  /**
+  * \brief Organizes geometries over proportional time steps
+  *
+  * For this TimeGeometry implementation it is assumed that
+  * the durations of the time steps are equidistant, e.g.
+  * the durations of the time steps in one ProportionalTimeGeometry
+  * are the same. The geometries of the time steps are independent,
+  * and not linked to each other. Since the timeBounds of the
+  * geometries are different for each time step it is not possible
+  * to set the same geometry to different time steps. Instead
+  * copies should be used.
+  *
+  * \addtogroup geometry
+  */
+  class MITK_CORE_EXPORT ProportionalTimeGeometry : public TimeGeometry
+  {
+  public:
+    mitkClassMacro(ProportionalTimeGeometry, TimeGeometry);
+
+    ProportionalTimeGeometry();
+    typedef ProportionalTimeGeometry self;
+    itkNewMacro(self);
+
+    /**
+    * \brief Returns the number of time steps.
+    *
+    * Returns the number of time steps for which
+    * geometries are saved. The number of time steps
+    * is also the upper bound of the time steps. The
+    * minimum time steps is always 0.
+    */
+    virtual TimeStepType     GetNumberOfTimeSteps() const;
+    /**
+    * \brief Returns the first time point for which the object is valid.
+    *
+    * Returns the first valid time point for this geometry. If only one
+    * time steps available it usually goes from -max to +max. The time point
+    * is given in ms.
+    */
+    virtual TimePointType    GetMinimumTimePoint () const;
+    /**
+    * \brief Returns the last time point for which the object is valid
+    *
+    * Gives the last time point for which a valid geometrie is saved in
+    * this time geometry. The time point is given in ms.
+    */
+    virtual TimePointType    GetMaximumTimePoint () const;
+
+    /**
+    * \brief Get the time bounds (in ms)
+    */
+    virtual TimeBounds GetTimeBounds( ) const;
+    /**
+    * \brief Tests if a given time point is covered by this object
+    *
+    * Returns true if a geometry can be returned for the given time
+    * point and falls if not. The time point must be given in ms.
+    */
+    virtual bool IsValidTimePoint (TimePointType timePoint) const;
+    /**
+    * \brief Test for the given time step if a geometry is availible
+    *
+    * Returns true if a geometry is defined for the given time step.
+    * Otherwise false is returned.
+    * The time step is defined as positiv number.
+    */
+    virtual bool IsValidTimeStep  (TimeStepType timeStep) const;
+    /**
+    * \brief Converts a time step to a time point
+    *
+    * Converts a time step to a time point in a way that
+    * the new time point indicates the same geometry as the time step.
+    * If the original time steps does not point to a valid geometry,
+    * a time point is calculated that also does not point to a valid
+    * geometry, but no exception is raised.
+    */
+    virtual TimePointType  TimeStepToTimePoint (TimeStepType timeStep) const;
+        /**
+    * \brief Converts a time point to the corresponding time step
+    *
+    * Converts a time point to a time step in a way that
+    * the new time step indicates the same geometry as the time point.
+    * If a negativ invalid time point is given always time step 0 is
+    * returned. If an positiv invalid time step is given an invalid
+    * time step will be returned.
+    */
+    virtual TimeStepType   TimePointToTimeStep (TimePointType timePoint) const;
+    /**
+    * \brief Returns the geometry which corresponds to the given time step
+    *
+    * Returns a clone of the geometry which defines the given time step. If
+    * the given time step is invalid an null-pointer is returned.
+    */
+    virtual Geometry3D::Pointer GetGeometryCloneForTimeStep( TimeStepType timeStep) const;
+
+    /**
+    * \brief Returns the geometry which corresponds to the given time point
+    *
+    * Returns the geometry which defines the given time point. If
+    * the given time point is invalid an null-pointer is returned.
+    *
+    * If the returned geometry is changed this will affect the saved
+    * geometry.
+    */
+    virtual Geometry3D::Pointer GetGeometryForTimePoint ( TimePointType timePoint) const;
+    /**
+    * \brief Returns the geometry which corresponds to the given time step
+    *
+    * Returns the geometry which defines the given time step. If
+    * the given time step is invalid an null-pointer is returned.
+    *
+    * If the returned geometry is changed this will affect the saved
+    * geometry.
+    */
+    virtual Geometry3D::Pointer GetGeometryForTimeStep  ( TimeStepType timeStep) const;
+
+    /**
+    * \brief Tests if all necessary informations are set and the object is valid
+    */
+    virtual bool IsValid () const;
+
+    /**
+    * \brief Initilizes a new object with one time steps which contains an empty geometry.
+    */
+    virtual void Initialize();
+
+    /**
+    * \brief Expands the time geometry to the given number of time steps.
+    *
+    * Initializes the new time steps with empty geometries.
+    * Shrinking is not supported.
+    */
+    virtual void Expand(TimeStepType size);
+    /**
+    * \brief Sets the geometry for the given time step
+    *
+    * This method does not afflict other time steps, since the geometry for
+    * each time step is saved individually.
+    */
+    virtual void SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep);
+
+    /**
+    * \brief Makes a deep copy of the current object
+    */
+    virtual itk::LightObject::Pointer InternalClone () const;
+
+    itkGetMacro(FirstTimePoint, TimePointType);
+    itkSetMacro(FirstTimePoint, TimePointType);
+    itkGetMacro(StepDuration, TimePointType);
+    itkSetMacro(StepDuration, TimePointType);
+
+//    void SetGeometryForTimeStep(TimeStepType timeStep, BaseGeometry& geometry);
+    void ClearAllGeometries ();
+//    void AddGeometry(BaseGeometry geometry);
+    void ReserveSpaceForGeometries (TimeStepType numberOfGeometries);
+
+    /**
+    * \brief Initializes the TimeGeometry with equally time Step geometries
+    *
+    * Saves a copy for each time step.
+    */
+    void Initialize (Geometry3D* geometry, TimeStepType timeSteps);
+    /**
+    * \brief Initialize the TimeGeometry with empty Geometry3D
+    */
+    void Initialize (TimeStepType timeSteps);
+
+  protected:
+    virtual ~ProportionalTimeGeometry();
+
+    std::vector<Geometry3D::Pointer> m_GeometryVector;
+    TimePointType m_FirstTimePoint;
+    TimePointType m_StepDuration;
+
+  }; // end class ProportialTimeGeometry
+
+} // end namespace MITK
+#endif // ProportionalTimeGeometry_h
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkSlicedData.cpp b/Core/Code/DataManagement/mitkSlicedData.cpp
index bfb5dcef8e..48d727bbfa 100644
--- a/Core/Code/DataManagement/mitkSlicedData.cpp
+++ b/Core/Code/DataManagement/mitkSlicedData.cpp
@@ -1,350 +1,344 @@
 /*===================================================================
 
 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(GetTimeSlicedGeometry() == NULL) return false;
+  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::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::Geometry2D* mitk::SlicedData::GetGeometry2D(int s, int t) const
 //{
 //  const_cast<SlicedData*>(this)->SetRequestedRegionToLargestPossibleRegion();
 //
 //  const_cast<SlicedData*>(this)->UpdateOutputInformation();
 //
 //  return GetSlicedGeometry(t)->GetGeometry2D(s);
 //}
 //
 mitk::SlicedGeometry3D* mitk::SlicedData::GetSlicedGeometry(unsigned int t) const
 {
-  if(GetTimeSlicedGeometry() == NULL)
+  if (GetTimeGeometry() == NULL)
     return NULL;
-  return dynamic_cast<SlicedGeometry3D*>(GetTimeSlicedGeometry()->GetGeometry3D(t));
+  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(Geometry3D* aGeometry3D)
 {
   if(aGeometry3D!=NULL)
   {
-    TimeSlicedGeometry::Pointer timeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(aGeometry3D);
-    if(timeSlicedGeometry.IsNull())
+    ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+    SlicedGeometry3D::Pointer slicedGeometry = dynamic_cast<SlicedGeometry3D*>(aGeometry3D);
+    if(slicedGeometry.IsNull())
     {
-      SlicedGeometry3D::Pointer slicedGeometry = dynamic_cast<SlicedGeometry3D*>(aGeometry3D);
-      if(slicedGeometry.IsNull())
+      Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(aGeometry3D);
+      if(geometry2d!=NULL)
       {
-        Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(aGeometry3D);
-        if(geometry2d!=NULL)
-        {
-          if((GetSlicedGeometry()->GetGeometry2D(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)));
-        }
+        if((GetSlicedGeometry()->GetGeometry2D(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());
-
-      timeSlicedGeometry = TimeSlicedGeometry::New();
-      timeSlicedGeometry->InitializeEvenlyTimed(slicedGeometry, 1);
     }
-    Superclass::SetGeometry(timeSlicedGeometry);
+    assert(slicedGeometry.IsNotNull());
+
+    timeGeometry->Initialize(slicedGeometry, 1);
+    Superclass::SetTimeGeometry(timeGeometry);
   }
   else
   {
     if(GetGeometry()==NULL)
       return;
     Superclass::SetGeometry(NULL);
   }
 }
 
 void mitk::SlicedData::SetSpacing(const float aSpacing[3])
 {
   this->SetSpacing((mitk::Vector3D)aSpacing);
 }
 
 void mitk::SlicedData::SetOrigin(const mitk::Point3D& origin)
 {
-  mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
+  TimeGeometry* timeGeometry = GetTimeGeometry();
 
-  assert(timeSlicedGeometry!=NULL);
+  assert(timeGeometry!=NULL);
 
   mitk::SlicedGeometry3D* slicedGeometry;
 
-  unsigned int steps = timeSlicedGeometry->GetTimeSteps();
+  unsigned int steps = timeGeometry->GetNumberOfTimeSteps();
 
   for(unsigned int timestep = 0; timestep < steps; ++timestep)
   {
     slicedGeometry = GetSlicedGeometry(timestep);
     if(slicedGeometry != NULL)
     {
       slicedGeometry->SetOrigin(origin);
       if(slicedGeometry->GetEvenlySpaced())
       {
         mitk::Geometry2D* geometry2D = slicedGeometry->GetGeometry2D(0);
         geometry2D->SetOrigin(origin);
         slicedGeometry->InitializeEvenlySpaced(geometry2D, slicedGeometry->GetSlices());
       }
     }
-    if(GetTimeSlicedGeometry()->GetEvenlyTimed())
-    {
-      GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, steps);
-      break;
-    }
+    //ProportionalTimeGeometry* timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(GetTimeGeometry());
+    //if(timeGeometry != NULL)
+    //{
+    //  timeGeometry->Initialize(slicedGeometry, steps);
+    //  break;
+    //}
   }
 }
 
 void mitk::SlicedData::SetSpacing(mitk::Vector3D aSpacing)
 {
-  mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
+  TimeGeometry* timeGeometry = GetTimeGeometry();
 
-  assert(timeSlicedGeometry!=NULL);
+  assert(timeGeometry!=NULL);
 
   mitk::SlicedGeometry3D* slicedGeometry;
 
-  unsigned int steps = timeSlicedGeometry->GetTimeSteps();
+  unsigned int steps = timeGeometry->GetNumberOfTimeSteps();
 
   for(unsigned int timestep = 0; timestep < steps; ++timestep)
   {
     slicedGeometry = GetSlicedGeometry(timestep);
     if(slicedGeometry != NULL)
     {
       slicedGeometry->SetSpacing(aSpacing);
     }
-    if(GetTimeSlicedGeometry()->GetEvenlyTimed())
-    {
-      GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, steps);
-      break;
-    }
   }
+  timeGeometry->Update();
 }
 
 
diff --git a/Core/Code/DataManagement/mitkSlicedData.h b/Core/Code/DataManagement/mitkSlicedData.h
index 0c26d36471..927b6fcf0b 100644
--- a/Core/Code/DataManagement/mitkSlicedData.h
+++ b/Core/Code/DataManagement/mitkSlicedData.h
@@ -1,222 +1,221 @@
 /*===================================================================
 
 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 <MitkExports.h>
 #include "mitkBaseData.h"
-#include "mitkTimeSlicedGeometry.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 Geometry2D
 //## 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);
 
   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 Geometry2D of the slice (@a s, @a t).
   ////##
   ////## The method does not simply call GetGeometry()->GetGeometry2D(). Before doing this, it
   ////## makes sure that the Geometry2D is up-to-date before returning it (by
   ////## setting the update extent appropriately and calling
   ////## UpdateOutputInformation).
   ////##
   ////## @warning GetGeometry2D not yet completely implemented.
   ////## @todo Appropriate setting of the update extent is missing.
   //virtual const mitk::Geometry2D* GetGeometry2D(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
   //## 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
   //## 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(Geometry3D* 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 float aSpacing[3]);
 
   //##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 a75aa54fde..c51c2dba65 100644
--- a/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
@@ -1,1025 +1,1029 @@
 /*===================================================================
 
 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 "mitkInteractionConst.h"
 #include "mitkSliceNavigationController.h"
 
 const float 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 )
   {
     Geometry2D::Pointer geometry = other.m_Geometry2Ds[0]->Clone();
     Geometry2D* geometry2D = dynamic_cast<Geometry2D*>(geometry.GetPointer());
     assert(geometry2D!=NULL);
     SetGeometry2D(geometry2D, 0);
   }
   else
   {
     unsigned int s;
     for ( s = 0; s < other.m_Slices; ++s )
     {
       if ( other.m_Geometry2Ds[s].IsNull() )
       {
         assert(other.m_EvenlySpaced);
         m_Geometry2Ds[s] = NULL;
       }
       else
       {
-        Geometry2D* geometry2D = other.m_Geometry2Ds[0]->Clone();
+        Geometry2D* geometry2D = other.m_Geometry2Ds[s]->Clone();
         assert(geometry2D!=NULL);
         SetGeometry2D(geometry2D, s);
       }
     }
   }
 }
 
 mitk::SlicedGeometry3D::~SlicedGeometry3D()
 {
 }
 
 
 mitk::Geometry2D *
 mitk::SlicedGeometry3D::GetGeometry2D( int s ) const
 {
   mitk::Geometry2D::Pointer geometry2D = NULL;
 
   if ( this->IsValidSlice(s) )
   {
     geometry2D = m_Geometry2Ds[s];
 
     // If (a) m_EvenlySpaced==true, (b) we don't have a Geometry2D 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() );
 
       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 * m_Spacing[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;
       }
     }
     return geometry2D;
   }
   else
   {
     return NULL;
   }
 }
 
 const mitk::BoundingBox *
 mitk::SlicedGeometry3D::GetBoundingBox() const
 {
   assert(m_BoundingBox.IsNotNull());
   return m_BoundingBox.GetPointer();
 }
 
 
 bool
 mitk::SlicedGeometry3D::SetGeometry2D( mitk::Geometry2D *geometry2D, int s )
 {
   if ( this->IsValidSlice(s) )
   {
     m_Geometry2Ds[s] = geometry2D;
     m_Geometry2Ds[s]->SetReferenceGeometry( m_ReferenceGeometry );
     return true;
   }
   return false;
 }
 
 
 void
 mitk::SlicedGeometry3D::InitializeSlicedGeometry( unsigned int slices )
 {
   Superclass::Initialize();
   m_Slices = slices;
 
   Geometry2D::Pointer gnull = NULL;
   m_Geometry2Ds.assign( m_Slices, gnull );
 
   Vector3D spacing;
   spacing.Fill( 1.0 );
   this->SetSpacing( spacing );
 
   m_DirectionVector.Fill( 0 );
 }
 
 
 void
 mitk::SlicedGeometry3D::InitializeEvenlySpaced(
   mitk::Geometry2D* 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::Geometry2D* 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
   Geometry2D::Pointer gnull = NULL;
   m_Geometry2Ds.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);
 
     m_IndexToWorldTransform = const_cast< AffineTransform3D * >(
       geometry2D->GetIndexToWorldTransform() );
   }
   else
   {
     directionVector *= -1.0;
     m_IndexToWorldTransform = AffineTransform3D::New();
     m_IndexToWorldTransform->SetMatrix(
       geometry2D->GetIndexToWorldTransform()->GetMatrix() );
 
     AffineTransform3D::OutputVectorType scaleVector;
     FillVector3D(scaleVector, 1.0, 1.0, -1.0);
     m_IndexToWorldTransform->Scale(scaleVector, true);
     m_IndexToWorldTransform->SetOffset(
       geometry2D->GetIndexToWorldTransform()->GetOffset() );
   }
 
   mitk::Vector3D spacing;
   FillVector3D( spacing,
     geometry2D->GetExtentInMM(0) / bounds[1],
     geometry2D->GetExtentInMM(1) / bounds[3],
     zSpacing );
 
   // Ensure that spacing differs from m_Spacing to make SetSpacing change the
   // matrix.
   m_Spacing[2] = zSpacing - 1;
 
   this->SetDirectionVector( directionVector );
   this->SetBounds( bounds );
   this->SetGeometry2D( geometry2D, 0 );
   this->SetSpacing( spacing );
   this->SetEvenlySpaced();
   this->SetTimeBounds( geometry2D->GetTimeBounds() );
 
   assert(m_IndexToWorldTransform.GetPointer()
          != geometry2D->GetIndexToWorldTransform()); // (**) see above.
 
   this->SetFrameOfReferenceID( geometry2D->GetFrameOfReferenceID() );
   this->SetImageGeometry( geometry2D->GetImageGeometry() );
 
   geometry2D->UnRegister();
 }
 
 
 void
 mitk::SlicedGeometry3D::InitializePlanes(
   const mitk::Geometry3D *geometry3D,
   mitk::PlaneGeometry::PlaneOrientation planeorientation,
   bool top, bool frontside, bool rotated )
 {
   m_ReferenceGeometry = const_cast< Geometry3D * >( 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() );
 
   // 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, Geometry2D::Pointer( NULL ) );
 
   if ( m_Slices > 0 )
   {
     m_Geometry2Ds[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
 {
-  Geometry3D::TransformType::Pointer inverse = Geometry3D::TransformType::New();
+  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::Geometry3D* geometry;
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
     geometry = m_Geometry2Ds[s];
     if ( geometry!=NULL )
     {
       geometry->SetImageGeometry( isAnImageGeometry );
     }
   }
 }
 
 void
 mitk::SlicedGeometry3D::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
 {
   mitk::Geometry3D* geometry;
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
     geometry = m_Geometry2Ds[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( Geometry3D *referenceGeometry )
 {
   m_ReferenceGeometry = referenceGeometry;
 
   std::vector<Geometry2D::Pointer>::iterator it;
 
   for ( it = m_Geometry2Ds.begin(); it != m_Geometry2Ds.end(); ++it )
   {
     (*it)->SetReferenceGeometry( referenceGeometry );
   }
 }
 
 void
 mitk::SlicedGeometry3D::SetSpacing( 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 Geometry2D,
   // since the spacing influences them
   if ((m_EvenlySpaced) && (m_Geometry2Ds.size() > 0))
   {
     mitk::Geometry2D::ConstPointer firstGeometry =
       m_Geometry2Ds[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;
     }
   }
 
   Superclass::SetSpacing(aSpacing);
 
   mitk::Geometry2D::Pointer firstGeometry;
 
   // In case of evenly-spaced data: re-initialize instances of Geometry2D,
   // 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 );
     planeGeometry->InitializeStandardPlane(
       rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &m_Spacing );
     planeGeometry->SetOrigin(origin);
     planeGeometry->SetBounds(bounds);
 
     firstGeometry = planeGeometry;
   }
   else if ( (m_EvenlySpaced) && (m_Geometry2Ds.size() > 0) )
   {
     firstGeometry = m_Geometry2Ds[0].GetPointer();
   }
 
   //clear and reserve
   Geometry2D::Pointer gnull=NULL;
   m_Geometry2Ds.assign(m_Slices, gnull);
 
   if ( m_Slices > 0 )
   {
     m_Geometry2Ds[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::SetTimeBounds( const mitk::TimeBounds& timebounds )
 {
   Superclass::SetTimeBounds( timebounds );
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
     if(m_Geometry2Ds[s].IsNotNull())
     {
       m_Geometry2Ds[s]->SetTimeBounds( timebounds );
     }
   }
   m_TimeBounds = 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 << "NULL" << std::endl;
   }
   else
   {
     this->GetGeometry2D(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
         Geometry2D::Pointer geometry2D = m_Geometry2Ds[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();
         }
 
         Geometry3D::ExecuteOperation( &centeredRotation );
       }
       else
       {
         // we also have to consider the case, that there is no reference geometry available.
         if ( m_Geometry2Ds.size() > 0 )
         {
            // Reach through to all slices in my container
            for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
               iter != m_Geometry2Ds.end();
               ++iter)
            {
-              (*iter)->ExecuteOperation(operation);
+              // 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 );
           Geometry3D::ExecuteOperation( rotOp);
         }
 
       }
     }
     else
     {
       // Reach through to all slices
       for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
           iter != m_Geometry2Ds.end();
           ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   case OpORIENT:
     if ( m_EvenlySpaced )
     {
        // get operation data
       PlaneOperation *planeOp = dynamic_cast< PlaneOperation * >( operation );
 
       // Get first slice
       Geometry2D::Pointer geometry2D = m_Geometry2Ds[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();
       float 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)
       Geometry3D::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();
 
          float 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)
          Geometry3D::ExecuteOperation( &op );
       }
     }
     else
     {
       // Reach through to all slices
       for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
           iter != m_Geometry2Ds.end();
           ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   case OpRESTOREPLANEPOSITION:
     if ( m_EvenlySpaced )
     {
       // Save first slice
       Geometry2D::Pointer geometry2D = m_Geometry2Ds[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, Geometry2D::Pointer( NULL ) );
 
          if ( m_Slices > 0 )
          {
            m_Geometry2Ds[0] = geometry2D;
          }
 
         m_SliceNavigationController->GetSlice()->SetSteps( m_Slices );
 
         this->Modified();
 
         //End Reinitialization
 
         if ( m_SliceNavigationController )
         {
           m_SliceNavigationController->GetSlice()->SetPos( restorePlaneOp->GetPos() );
           m_SliceNavigationController->AdjustSliceStepperRange();
         }
         Geometry3D::ExecuteOperation(restorePlaneOp);
       }
     }
     else
     {
       // Reach through to all slices
       for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
           iter != m_Geometry2Ds.end();
           ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   }
 
   this->Modified();
 }
 
diff --git a/Core/Code/DataManagement/mitkSurface.cpp b/Core/Code/DataManagement/mitkSurface.cpp
index 24573d5efb..0a390a5b8b 100644
--- a/Core/Code/DataManagement/mitkSurface.cpp
+++ b/Core/Code/DataManagement/mitkSurface.cpp
@@ -1,540 +1,541 @@
 /*===================================================================
 
 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 "mitkSurface.h"
 #include "mitkInteractionConst.h"
 #include "mitkSurfaceOperation.h"
 
 #include <algorithm>
 #include <vtkPolyData.h>
 #include <mitkTesting.h>
 
 static vtkPolyData* DeepCopy(vtkPolyData* other)
 {
   if (other == NULL)
     return NULL;
 
   vtkPolyData* copy = vtkPolyData::New();
   copy->DeepCopy(other);
 
   return copy;
 }
 
 static void Delete(vtkPolyData* polyData)
 {
   if (polyData != NULL)
     polyData->Delete();
 }
 
 static void Update(vtkPolyData* polyData)
 {
   if (polyData != NULL)
     polyData->Update();
 }
 
 mitk::Surface::Surface()
   : m_CalculateBoundingBox(false)
 {
   this->InitializeEmpty();
 }
 
 mitk::Surface::Surface(const mitk::Surface& other)
   : BaseData(other),
     m_LargestPossibleRegion(other.m_LargestPossibleRegion),
     m_RequestedRegion(other.m_RequestedRegion),
     m_CalculateBoundingBox(other.m_CalculateBoundingBox)
 {
   if(!other.m_PolyDatas.empty())
   {
     m_PolyDatas.resize(other.m_PolyDatas.size());
     std::transform(other.m_PolyDatas.begin(), other.m_PolyDatas.end(), m_PolyDatas.begin(), DeepCopy);
   }
   else
   {
     this->InitializeEmpty();
   }
 }
 
 void mitk::Surface::Swap(mitk::Surface& other)
 {
   std::swap(m_PolyDatas, other.m_PolyDatas);
   std::swap(m_LargestPossibleRegion, other.m_LargestPossibleRegion);
   std::swap(m_RequestedRegion, other.m_RequestedRegion);
   std::swap(m_CalculateBoundingBox, other.m_CalculateBoundingBox);
 }
 
 mitk::Surface& mitk::Surface::operator=(Surface other)
 {
   this->Swap(other);
   return *this;
 }
 
 mitk::Surface::~Surface()
 {
   this->ClearData();
 }
 
 void mitk::Surface::ClearData()
 {
   using ::Delete;
 
   std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Delete);
   m_PolyDatas.clear();
 
   Superclass::ClearData();
 }
 
 const mitk::Surface::RegionType& mitk::Surface::GetLargestPossibleRegion() const
 {
   m_LargestPossibleRegion.SetIndex(3, 0);
-  m_LargestPossibleRegion.SetSize(3, GetTimeSlicedGeometry()->GetTimeSteps());
+  m_LargestPossibleRegion.SetSize(3, GetTimeGeometry()->GetNumberOfTimeSteps());
 
   return m_LargestPossibleRegion;
 }
 
 const mitk::Surface::RegionType& mitk::Surface::GetRequestedRegion() const
 {
   return m_RequestedRegion;
 }
 
 void mitk::Surface::InitializeEmpty()
 {
   if (!m_PolyDatas.empty())
     this->ClearData();
 
-  Superclass::InitializeTimeSlicedGeometry();
+  Superclass::InitializeTimeGeometry();
 
   m_PolyDatas.push_back(NULL);
   m_Initialized = true;
 }
 
 void mitk::Surface::SetVtkPolyData(vtkPolyData* polyData, unsigned int t)
 {
   this->Expand(t + 1);
 
   if (m_PolyDatas[t] != NULL)
   {
     if (m_PolyDatas[t] == polyData)
       return;
 
     m_PolyDatas[t]->Delete();
   }
 
   m_PolyDatas[t] = polyData;
 
   if(polyData != NULL)
     polyData->Register(NULL);
 
   m_CalculateBoundingBox = true;
 
   this->Modified();
   this->UpdateOutputInformation();
 }
 
 bool mitk::Surface::IsEmptyTimeStep(unsigned int t) const
 {
   if(!IsInitialized())
     return false;
 
   vtkPolyData* polyData = const_cast<Surface*>(this)->GetVtkPolyData(t);
 
   return polyData == NULL || (
     polyData->GetNumberOfLines() == 0 &&
     polyData->GetNumberOfPolys() == 0 &&
     polyData->GetNumberOfStrips() == 0 &&
     polyData->GetNumberOfVerts() == 0
   );
 }
 
 vtkPolyData* mitk::Surface::GetVtkPolyData(unsigned int t)
 {
   if (t < m_PolyDatas.size())
   {
     if(m_PolyDatas[t] == NULL && this->GetSource().IsNotNull())
     {
       RegionType requestedRegion;
       requestedRegion.SetIndex(3, t);
       requestedRegion.SetSize(3, 1);
 
       this->SetRequestedRegion(&requestedRegion);
       this->GetSource()->Update();
     }
 
     return m_PolyDatas[t];
   }
 
   return NULL;
 }
 
 void mitk::Surface::UpdateOutputInformation()
 {
   if (this->GetSource().IsNotNull())
     this->GetSource()->UpdateOutputInformation();
 
   if (m_CalculateBoundingBox == true && !m_PolyDatas.empty())
     this->CalculateBoundingBox();
   else
-    this->GetTimeSlicedGeometry()->UpdateInformation();
+    this->GetTimeGeometry()->Update();
 }
 
 void mitk::Surface::CalculateBoundingBox()
 {
-  mitk::TimeSlicedGeometry* timeSlicedGeometry = this->GetTimeSlicedGeometry();
+  TimeGeometry* timeGeometry = this->GetTimeGeometry();
 
-  if (timeSlicedGeometry->GetTimeSteps() != m_PolyDatas.size())
+  if (timeGeometry->GetNumberOfTimeSteps() != m_PolyDatas.size())
     mitkThrow() << "Number of geometry time steps is inconsistent with number of poly data pointers.";
 
   for (unsigned int i = 0; i < m_PolyDatas.size(); ++i)
   {
     vtkPolyData* polyData = m_PolyDatas[i];
     vtkFloatingPointType bounds[6] = {0};
 
     if (polyData != NULL && polyData->GetNumberOfPoints() > 0)
     {
       polyData->Update();
       polyData->ComputeBounds();
       polyData->GetBounds(bounds);
     }
 
-    mitk::Geometry3D::Pointer geometry = timeSlicedGeometry->GetGeometry3D(i);
+    Geometry3D::Pointer geometry = timeGeometry->GetGeometryForTimeStep(i);
 
     if (geometry.IsNull())
       mitkThrow() << "Time-sliced geometry is invalid (equals NULL).";
 
     geometry->SetFloatBounds(bounds);
   }
 
-  timeSlicedGeometry->UpdateInformation();
+  timeGeometry->Update();
   m_CalculateBoundingBox = false;
 }
 
 void mitk::Surface::SetRequestedRegionToLargestPossibleRegion()
 {
   m_RequestedRegion = GetLargestPossibleRegion();
 }
 
 bool mitk::Surface::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3);
 
   if(static_cast<RegionType::IndexValueType>(m_PolyDatas.size()) < end)
     return true;
 
   for(RegionType::IndexValueType t = m_RequestedRegion.GetIndex(3); t < end; ++t)
   {
     if(m_PolyDatas[t] == NULL)
       return true;
   }
 
   return false;
 }
 
 bool mitk::Surface::VerifyRequestedRegion()
 {
   if(m_RequestedRegion.GetIndex(3) >= 0 && m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3) <= m_PolyDatas.size())
     return true;
 
   return false;
 }
 
 void mitk::Surface::SetRequestedRegion(const itk::DataObject* data )
 {
   const mitk::Surface *surface = dynamic_cast<const mitk::Surface*>(data);
 
   if (surface != NULL)
     m_RequestedRegion = surface->GetRequestedRegion();
   else
     mitkThrow() << "Data object used to get requested region is not a mitk::Surface.";
 }
 
 void mitk::Surface::SetRequestedRegion(Surface::RegionType* region)
 {
   if (region == NULL)
     mitkThrow() << "Requested region is invalid (equals NULL)";
 
   m_RequestedRegion = *region;
 }
 
 void mitk::Surface::CopyInformation(const itk::DataObject* data)
 {
   Superclass::CopyInformation(data);
 
   const mitk::Surface* surface = dynamic_cast<const mitk::Surface*>(data);
 
   if (surface == NULL)
     mitkThrow() << "Data object used to get largest possible region is not a mitk::Surface.";
 
   m_LargestPossibleRegion = surface->GetLargestPossibleRegion();
 }
 
 void mitk::Surface::Update()
 {
   using ::Update;
 
   if (this->GetSource().IsNull())
     std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Update);
 
   Superclass::Update();
 }
 
 void mitk::Surface::Expand(unsigned int timeSteps)
 {
   if (timeSteps > m_PolyDatas.size())
   {
     Superclass::Expand(timeSteps);
 
     m_PolyDatas.resize(timeSteps);
     m_CalculateBoundingBox = true;
   }
 }
 
 void mitk::Surface::ExecuteOperation(Operation* operation)
 {
   switch (operation->GetOperationType())
   {
     case OpSURFACECHANGED:
     {
       mitk::SurfaceOperation* surfaceOperation = dynamic_cast<mitk::SurfaceOperation*>(operation);
 
       if(surfaceOperation == NULL)
         break;
 
       unsigned int timeStep = surfaceOperation->GetTimeStep();
 
       if(m_PolyDatas[timeStep] != NULL)
       {
         vtkPolyData* updatedPolyData = surfaceOperation->GetVtkPolyData();
 
         if(updatedPolyData != NULL)
         {
           this->SetVtkPolyData(updatedPolyData, timeStep);
           this->CalculateBoundingBox();
           this->Modified();
         }
       }
 
       break;
     }
 
     default:
       return;
   }
 }
 
 unsigned int mitk::Surface::GetSizeOfPolyDataSeries() const
 {
   return m_PolyDatas.size();
 }
 
 void mitk::Surface::Graft(const DataObject* data)
 {
   const Surface* surface = dynamic_cast<const Surface*>(data);
 
   if(surface == NULL)
     mitkThrow() << "Data object used to graft surface is not a mitk::Surface.";
 
   this->CopyInformation(data);
   m_PolyDatas.clear();
 
   for (unsigned int i = 0; i < surface->GetSizeOfPolyDataSeries(); ++i)
   {
     m_PolyDatas.push_back(vtkPolyData::New());
     m_PolyDatas.back()->DeepCopy(const_cast<mitk::Surface*>(surface)->GetVtkPolyData(i));
   }
 }
 
 void mitk::Surface::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 
   os << indent << "\nNumber PolyDatas: " << m_PolyDatas.size() << "\n";
 
   unsigned int count = 0;
 
   for (std::vector<vtkPolyData*>::const_iterator it = m_PolyDatas.begin(); it != m_PolyDatas.end(); ++it)
   {
     os << "\n";
 
     if(*it != NULL)
     {
       os << indent << "PolyData at time step " << count << ":\n";
       os << indent << "Number of cells: " << (*it)->GetNumberOfCells() << "\n";
       os << indent << "Number of points: " << (*it)->GetNumberOfPoints() << "\n\n";
       os << indent << "VTKPolyData:\n";
 
       (*it)->Print(os);
     }
     else
     {
       os << indent << "Empty PolyData at time step " << count << "\n";
     }
 
     ++count;
   }
 }
 
 bool mitk::Equal( vtkPolyData* leftHandSide, vtkPolyData* rightHandSide, mitk::ScalarType eps, bool verbose )
 {
   bool noDifferenceFound = true;
 
   if( rightHandSide == NULL )
   {
     if(verbose)
     {
       MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] rightHandSide NULL.";
     }
     return false;
   }
 
   if( leftHandSide == NULL )
   {
     if(verbose)
     {
       MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] leftHandSide NULL.";
     }
     return false;
   }
 
   if( ! mitk::Equal( leftHandSide->GetNumberOfCells(), rightHandSide->GetNumberOfCells(), eps, verbose ) )
   {
     if(verbose)
       MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of cells not equal";
     noDifferenceFound = false;
   }
 
   if( ! mitk::Equal( leftHandSide->GetNumberOfVerts(), rightHandSide->GetNumberOfVerts(), eps, verbose ))
   {
     if(verbose)
       MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of vertices not equal";
     noDifferenceFound = false;
   }
 
   if( ! mitk::Equal( leftHandSide->GetNumberOfLines(), rightHandSide->GetNumberOfLines(), eps, verbose ) )
   {
     if(verbose)
       MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of lines not equal";
     noDifferenceFound = false;
   }
 
   if( ! mitk::Equal( leftHandSide->GetNumberOfPolys(), rightHandSide->GetNumberOfPolys(), eps, verbose ) )
   {
     if(verbose)
       MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of polys not equal";
     noDifferenceFound = false;
   }
 
   if( ! mitk::Equal( leftHandSide->GetNumberOfStrips(), rightHandSide->GetNumberOfStrips(), eps, verbose ) )
   {
     if(verbose)
       MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of strips not equal";
     noDifferenceFound = false;
   }
 
   {
     unsigned int numberOfPointsRight = rightHandSide->GetPoints()->GetNumberOfPoints();
     unsigned int numberOfPointsLeft = leftHandSide->GetPoints()->GetNumberOfPoints();
     if(! mitk::Equal( numberOfPointsLeft, numberOfPointsRight, eps, verbose ))
     {
       if(verbose)
         MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of points not equal";
       noDifferenceFound = false;
     }
     else
     {
       for( unsigned int i( 0 ); i < numberOfPointsRight; i++ )
       {
         bool pointFound = false;
         double pointOne[3];
         rightHandSide->GetPoints()->GetPoint(i, pointOne);
 
         for( unsigned int j( 0 ); j < numberOfPointsLeft; j++ )
         {
           double pointTwo[3];
           leftHandSide->GetPoints()->GetPoint(j, pointTwo);
 
           double x = pointOne[0] - pointTwo[0];
           double y = pointOne[1] - pointTwo[1];
           double z = pointOne[2] - pointTwo[2];
           double distance = x*x + y*y + z*z;
 
           if( distance < eps )
           {
             pointFound = true;
             break;
           }
         }
         if( !pointFound )
         {
           if(verbose)
           {
             MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Right hand side point with id " << i << " and coordinates ( "
                     << std::setprecision(12)
                     << pointOne[0] << " ; " << pointOne[1] << " ; " << pointOne[2]
                     << " ) could not be found in left hand side with epsilon " << eps << ".";
           }
           noDifferenceFound = false;
           break;
         }
       }
     }
   }
   return noDifferenceFound;
 }
 
 bool mitk::Equal( mitk::Surface* leftHandSide, mitk::Surface* rightHandSide, mitk::ScalarType eps, bool verbose )
 {
   bool noDifferenceFound = true;
 
   if( rightHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] rightHandSide NULL.";
     return false;
   }
 
   if( leftHandSide == NULL )
   {
     if(verbose)
       MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] leftHandSide NULL.";
     return false;
   }
 
   if( ! mitk::Equal( leftHandSide->GetSizeOfPolyDataSeries(), rightHandSide->GetSizeOfPolyDataSeries(), eps, verbose ) )
   {
     if(verbose)
       MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] Size of PolyData series not equal.";
     noDifferenceFound = false;
   }
 
-  if( ! mitk::Equal( leftHandSide->GetTimeSlicedGeometry(), rightHandSide->GetTimeSlicedGeometry(), eps, verbose ) )
-  {
-    if(verbose)
-      MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] Time sliced geometries not equal";
-    noDifferenceFound = false;
-  }
+  // No mitk::Equal for TimeGeometry implemented.
+  //if( ! mitk::Equal( leftHandSide->GetTimeGeometry(), rightHandSide->GetTimeGeometry(), eps, verbose ) )
+  //{
+  //  if(verbose)
+  //    MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] Time sliced geometries not equal";
+  //  noDifferenceFound = false;
+  //}
 
   for( unsigned int i( 0 ); i < rightHandSide->GetSizeOfPolyDataSeries(); i++ )
   {
     if( ! mitk::Equal( leftHandSide->GetVtkPolyData( i ), rightHandSide->GetVtkPolyData( i ), eps, verbose ) )
     {
       if(verbose)
         MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] Poly datas not equal.";
       noDifferenceFound = false;
     }
   }
 
   return noDifferenceFound;
-}
+}
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp b/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
index a411ad1054..d7388b197c 100644
--- a/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
+++ b/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
@@ -1,102 +1,102 @@
 /*===================================================================
 
 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 "mitkThinPlateSplineCurvedGeometry.h"
 #include <vtkThinPlateSplineTransform.h>
 #include <vtkPoints.h>
 
 mitk::ThinPlateSplineCurvedGeometry::ThinPlateSplineCurvedGeometry()
 {
   m_InterpolatingAbstractTransform = m_ThinPlateSplineTransform = vtkThinPlateSplineTransform::New();
 
   m_VtkTargetLandmarks = vtkPoints::New();
   m_VtkProjectedLandmarks = vtkPoints::New();
   m_ThinPlateSplineTransform->SetInverseIterations(5000);
 }
 
 mitk::ThinPlateSplineCurvedGeometry::ThinPlateSplineCurvedGeometry(const ThinPlateSplineCurvedGeometry& other ) : Superclass(other)
 {
   this->SetSigma(other.GetSigma());
 }
 
 mitk::ThinPlateSplineCurvedGeometry::~ThinPlateSplineCurvedGeometry()
 {
   // don't need to delete m_ThinPlateSplineTransform, because it is
   // the same as m_InterpolatingAbstractTransform, which will be deleted
   // by the superclass.
 
   if(m_VtkTargetLandmarks!=NULL)
     m_VtkTargetLandmarks->Delete();
   if(m_VtkProjectedLandmarks!=NULL)
     m_VtkProjectedLandmarks->Delete();
 }
 
 bool mitk::ThinPlateSplineCurvedGeometry::IsValid() const
 {
   return m_TargetLandmarks.IsNotNull() && (m_TargetLandmarks->Size() >= 3) && m_LandmarkProjector.IsNotNull();
 }
 
 void mitk::ThinPlateSplineCurvedGeometry::SetSigma(float sigma)
 {
   m_ThinPlateSplineTransform->SetSigma(sigma);
 }
 
 float mitk::ThinPlateSplineCurvedGeometry::GetSigma() const
 {
   return m_ThinPlateSplineTransform->GetSigma();
 
 }
 
 void mitk::ThinPlateSplineCurvedGeometry::ComputeGeometry()
 {
   Superclass::ComputeGeometry();
 
   const mitk::PointSet::DataType::PointsContainer *finalTargetLandmarks, *projectedTargetLandmarks;
 
   finalTargetLandmarks = m_LandmarkProjector->GetFinalTargetLandmarks();
   projectedTargetLandmarks = m_LandmarkProjector->GetProjectedLandmarks();
 
   mitk::PointSet::DataType::PointsContainer::ConstIterator targetIt, projectedIt;
 
   targetIt    = finalTargetLandmarks->Begin();
   projectedIt = projectedTargetLandmarks->Begin();
 
   //initialize Thin-Plate-Spline
   m_VtkTargetLandmarks->Reset();
   m_VtkProjectedLandmarks->Reset();
   vtkIdType id;
   int size=finalTargetLandmarks->Size();
   for(id=0; id < size; ++id, ++targetIt, ++projectedIt)
   {
     const mitk::PointSet::PointType& target = targetIt->Value();
     m_VtkTargetLandmarks->InsertPoint(id, target[0], target[1], target[2]);
     const mitk::PointSet::PointType& projected = projectedIt->Value();
     m_VtkProjectedLandmarks->InsertPoint(id, projected[0], projected[1], projected[2]);
   }
   m_VtkTargetLandmarks->Modified();
   m_VtkProjectedLandmarks->Modified();
 
   m_ThinPlateSplineTransform->SetSourceLandmarks(m_VtkProjectedLandmarks);
   m_ThinPlateSplineTransform->SetTargetLandmarks(m_VtkTargetLandmarks);
 }
 
 itk::LightObject::Pointer mitk::ThinPlateSplineCurvedGeometry::InternalClone() const
 {
- mitk::AffineGeometryFrame3D::Pointer newGeometry = new Self(*this);
- newGeometry->UnRegister();
- return newGeometry.GetPointer();
+  mitk::Geometry3D::Pointer newGeometry = new Self(*this);
+  newGeometry->UnRegister();
+  return newGeometry.GetPointer();
 }
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.cpp b/Core/Code/DataManagement/mitkTimeGeometry.cpp
new file mode 100644
index 0000000000..59b844e9aa
--- /dev/null
+++ b/Core/Code/DataManagement/mitkTimeGeometry.cpp
@@ -0,0 +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.
+
+===================================================================*/
+#include <mitkTimeGeometry.h>
+
+#include <mitkGeometry3D.h>
+#include <mitkExceptionMacro.h>
+
+mitk::TimeGeometry::TimeGeometry() :
+  m_BoundingBox(BoundingBox::New())
+{
+  typedef BoundingBox::PointsContainer ContainerType;
+  ContainerType::Pointer points = ContainerType::New();
+  m_BoundingBox->SetPoints(points.GetPointer());
+}
+
+mitk::TimeGeometry::~TimeGeometry()
+{
+}
+
+void mitk::TimeGeometry::Initialize()
+{
+}
+
+
+/* \brief short description
+ * parameters
+ *
+ */
+mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorld(int id) const
+{
+  assert(id >= 0);
+  assert(m_BoundingBox.IsNotNull());
+
+  BoundingBox::BoundsArrayType bounds = m_BoundingBox->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.");
+        return Point3D();
+      }
+  }
+
+  // TimeGeometry has no Transformation. Therefore the bounding box
+  // contains all data in world coordinates
+  return cornerpoint;
+}
+
+mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorld(bool xFront, bool yFront, bool zFront) const
+{
+  assert(m_BoundingBox.IsNotNull());
+  BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
+
+  Point3D cornerpoint;
+  cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
+  cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
+  cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
+
+  return cornerpoint;
+}
+
+mitk::Point3D mitk::TimeGeometry::GetCenterInWorld() const
+{
+  assert(m_BoundingBox.IsNotNull());
+  return m_BoundingBox->GetCenter();
+}
+
+double mitk::TimeGeometry::GetDiagonalLength2InWorld() const
+{
+  Vector3D diagonalvector = GetCornerPointInWorld()-GetCornerPointInWorld(false, false, false);
+  return diagonalvector.GetSquaredNorm();
+}
+
+double mitk::TimeGeometry::GetDiagonalLengthInWorld() const
+{
+  return sqrt(GetDiagonalLength2InWorld());
+}
+
+bool mitk::TimeGeometry::IsWorldPointInside(const mitk::Point3D& p) const
+{
+  return m_BoundingBox->IsInside(p);
+}
+
+void mitk::TimeGeometry::UpdateBoundingBox ()
+{
+  assert(m_BoundingBox.IsNotNull());
+  typedef BoundingBox::PointsContainer ContainerType;
+
+  unsigned long lastModifiedTime = 0;
+  unsigned long currentModifiedTime = 0;
+
+  ContainerType::Pointer points = ContainerType::New();
+  points->reserve(2*GetNumberOfTimeSteps());
+  for (TimeStepType step = 0; step <GetNumberOfTimeSteps(); ++step)
+  {
+    currentModifiedTime = GetGeometryForTimeStep(step)->GetMTime();
+    if (currentModifiedTime > lastModifiedTime)
+      lastModifiedTime = currentModifiedTime;
+
+    Point3D minimum = GetGeometryForTimeStep(step)->GetCornerPoint(false,false,false);
+    Point3D maximum = GetGeometryForTimeStep(step)->GetCornerPoint(true,true,true);
+
+    points->push_back(minimum);
+    points->push_back(maximum);
+  }
+  m_BoundingBox->SetPoints(points);
+  m_BoundingBox->ComputeBoundingBox();
+  if (this->GetMTime() < lastModifiedTime)
+    this->Modified();
+
+}
+
+mitk::ScalarType mitk::TimeGeometry::GetExtentInWorld (unsigned int direction) const
+{
+  assert(direction < 3);
+  assert(m_BoundingBox.IsNotNull());
+  BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
+  return bounds[direction * 2 + 1] - bounds[direction * 2];
+}
+
+void mitk::TimeGeometry::Update()
+{
+  this->UpdateBoundingBox();
+  this->UpdateWithoutBoundingBox();
+}
+
+void mitk::TimeGeometry::ExecuteOperation(mitk::Operation* op)
+{
+  for (TimeStepType step = 0; step < GetNumberOfTimeSteps(); ++step)
+  {
+    GetGeometryForTimeStep(step)->ExecuteOperation(op);
+  }
+}
+
+void mitk::TimeGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
+{
+  //Superclass::PrintSelf(os,indent);
+  os << indent << " TimeSteps: " << this->GetNumberOfTimeSteps() << std::endl;
+
+  os << std::endl;
+  os << indent << " GetGeometryForTimeStep(0): ";
+  if(GetGeometryForTimeStep(0).IsNull())
+    os << "NULL" << std::endl;
+  else
+    GetGeometryForTimeStep(0)->Print(os, indent);
+}
+
+itk::LightObject::Pointer mitk::TimeGeometry::InternalClone() const
+{
+  itk::LightObject::Pointer parent = Superclass::InternalClone();
+  Self::Pointer rval = dynamic_cast<Self *> (parent.GetPointer());
+  if (rval.IsNull())
+  {
+    mitkThrow() << " Downcast to type " << this->GetNameOfClass() << " failed.";
+  }
+  rval->m_BoundingBox = m_BoundingBox->Clone();
+  return parent;
+}
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.h b/Core/Code/DataManagement/mitkTimeGeometry.h
new file mode 100644
index 0000000000..cb88323b3e
--- /dev/null
+++ b/Core/Code/DataManagement/mitkTimeGeometry.h
@@ -0,0 +1,288 @@
+/*===================================================================
+
+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 TimeGeometry_h
+#define TimeGeometry_h
+
+//ITK
+#include <itkObject.h>
+//MITK
+#include <mitkCommon.h>
+#include <MitkExports.h>
+#include "mitkOperationActor.h"
+#include <mitkGeometry3D.h>
+
+
+namespace mitk {
+
+  /**
+  * \deprecatedSince{2013_09} GlobalInteraction is deprecated. It is replaced by mitk::Dispatcher.
+  *  Please use the new implementation described in \see DataInteractionPage .
+  */
+
+  typedef float         TimePointType;
+  typedef std::size_t   TimeStepType;
+
+  /**
+  * \brief Manages the geometries of a data object for each time step
+  *
+  * This class is an abstract class. The concrete implementation
+  * depends on the way the different time steps are managed.
+  *
+  * The time is defined either by a time step or a time point. Time steps
+  * are non-negativ integers starting from 0. A time point is is an float value
+  * which gives the passed time since start in ms. Be aware that the starting
+  * point is not fixed so it is possible that the same time point  defines two
+  * different time depending on the start time of the used time geometry.
+  *
+  * \addtogroup geometry
+  */
+  class MITK_CORE_EXPORT TimeGeometry : public itk::Object, public OperationActor
+  {
+  protected:
+    TimeGeometry();
+    virtual ~TimeGeometry();
+
+    /**
+    * \brief Contains a bounding box which includes all time steps
+    */
+    BoundingBox::Pointer m_BoundingBox;
+
+    /**
+    * \brief Makes a deep copy of the current object
+    */
+    virtual LightObject::Pointer InternalClone() const;
+
+
+  public:
+    mitkClassMacro(TimeGeometry, itk::Object);
+    itkCloneMacro(Self);
+    itkCreateAnotherMacro(Self);
+    /**
+    * \brief Returns the number of time steps.
+    *
+    * Returns the number of time steps for which
+    * geometries are saved. The number of time steps
+    * is also the upper bound of the time steps. The
+    * minimum time steps is always 0.
+    */
+    virtual TimeStepType     GetNumberOfTimeSteps() const = 0;
+    /**
+    * \brief Returns the first time point for which the object is valid.
+    *
+    * Returns the first valid time point for this geometry. If only one
+    * time steps available it usually goes from -max to +max. The time point
+    * is given in ms.
+    */
+    virtual TimePointType    GetMinimumTimePoint () const = 0;
+    /**
+    * \brief Returns the last time point for which the object is valid
+    *
+    * Gives the last time point for which a valid geometrie is saved in
+    * this time geometry. The time point is given in ms.
+    */
+    virtual TimePointType    GetMaximumTimePoint () const = 0;
+
+    /**
+    * \brief Get the time bounds (in ms)
+    */
+    virtual TimeBounds GetTimeBounds( ) const = 0;
+    /**
+    * \brief Tests if a given time point is covered by this object
+    *
+    * Returns true if a geometry can be returned for the given time
+    * point and falls if not. The time point must be given in ms.
+    */
+    virtual bool IsValidTimePoint (TimePointType timePoint) const = 0;
+    /**
+    * \brief Test for the given time step if a geometry is availible
+    *
+    * Returns true if a geometry is defined for the given time step.
+    * Otherwise false is returned.
+    * The time step is defined as positiv number.
+    */
+    virtual bool IsValidTimeStep  (TimeStepType timeStep) const = 0;
+
+    /**
+    * \brief Converts a time step to a time point
+    *
+    * Converts a time step to a time point in a way that
+    * the new time point indicates the same geometry as the time step.
+    * If the original time steps does not point to a valid geometry,
+    * a time point is calculated that also does not point to a valid
+    * geometry, but no exception is raised.
+    */
+    virtual TimePointType  TimeStepToTimePoint (TimeStepType timeStep) const = 0;
+    /**
+    * \brief Converts a time point to the corresponding time step
+    *
+    * Converts a time point to a time step in a way that
+    * the new time step indicates the same geometry as the time point.
+    * If a negativ invalid time point is given always time step 0 is
+    * returned. If an positiv invalid time step is given an invalid
+    * time step will be returned.
+    */
+    virtual TimeStepType   TimePointToTimeStep (TimePointType timePoint) const = 0;
+
+    /**
+    * \brief Returns the geometry of a specific time point
+    *
+    * Returns the geometry which defines the given time point. If
+    * the given time point is invalid an null-pointer is returned.
+    *
+    * The pointer to the returned geometry may point to the saved
+    * geometry but this is not necessarily the case. So a change to
+    * the returned geometry may or may not afflict the geometry for the
+    * time point or all time points depending on the used implementation
+    * of TimeGeometry.
+    */
+    virtual Geometry3D::Pointer GetGeometryForTimePoint ( TimePointType timePoint) const = 0;
+    /**
+    * \brief Returns the geometry which corresponds to the given time step
+    *
+    * Returns the geometry which defines the given time step. If
+    * the given time step is invalid an null-pointer is returned.
+    *
+    * The pointer to the returned geometry may point to the saved
+    * geometry but this is not necessarily the case. So a change to
+    * the returned geometry may or may not afflict the geometry for the
+    * time step or all time steps depending on the used implementation
+    * of TimeGeometry.
+    */
+    virtual Geometry3D::Pointer GetGeometryForTimeStep ( TimeStepType timeStep) const = 0;
+
+    /**
+    * \brief Returns a clone of the geometry of a specific time point
+    *
+    * If an invalid time step is given (e.g. no geometry is defined for this time step)
+    * a null-pointer will be returned.
+    */
+    virtual Geometry3D::Pointer GetGeometryCloneForTimeStep( TimeStepType timeStep) const = 0;
+    /**
+    * \brief Sets the geometry for a given time step
+    *
+    * Sets the geometry for the given time steps. This may also afflects other
+    * time steps, depending on the implementation of TimeGeometry.
+    */
+    virtual void SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep) = 0;
+
+    /**
+    * \brief Expands to the given number of time steps
+    *
+    * Expands to the given number of time steps. Each new created time
+    * step is filled with an empty geometry.
+    * Shrinking is not supported!
+    */
+    virtual void Expand(TimeStepType size) = 0;
+
+    /**
+    * \brief Tests if all necessary informations are set and the object is valid
+    */
+    virtual bool IsValid () const = 0;
+    /**
+    * \brief Get the position of the corner number \a id (in world coordinates)
+    *
+    * See SetImageGeometry for how a corner is defined on images.
+    */
+    Point3D GetCornerPointInWorld(int id) const;
+
+    /**
+    * \brief Get the position of a corner (in world coordinates)
+    *
+    * See SetImageGeometry for how a corner is defined on images.
+    */
+    Point3D GetCornerPointInWorld(bool xFront=true, bool yFront=true, bool zFront=true) const;
+
+    /**
+    * \brief Get the center of the bounding-box in mm
+    */
+    Point3D GetCenterInWorld() const;
+
+    /**
+    * \brief Get the squared length of the diagonal of the bounding-box in mm
+    */
+    double GetDiagonalLength2InWorld() const;
+
+    /**
+    * \brief Get the length of the diagonal of the bounding-box in mm
+    */
+    double GetDiagonalLengthInWorld() const;
+
+    /**
+    * \brief Test whether the point \a p (world coordinates in mm) is inside the bounding box
+    */
+    bool IsWorldPointInside(const mitk::Point3D& p) const;
+
+    /**
+    * \brief Updates the bounding box to cover the area used in all time steps
+    *
+    * The bounding box is updated by this method. The new bounding box
+    * covers an area which includes all bounding boxes during
+    * all times steps.
+    */
+    void UpdateBoundingBox();
+
+    /**
+    * \brief Returns a bounding box that covers all time steps
+    */
+    BoundingBox* GetBoundingBoxInWorld() const
+    {
+      return m_BoundingBox;
+    }
+
+    /**
+    * \brief Returns the world bounds of the object that cover all time steps
+    */
+    BoundingBox::BoundsArrayType GetBoundsInWorld() const
+    {
+      return m_BoundingBox->GetBounds();
+    }
+
+    /**
+    * \brief Returns the Extend of the bounding in the given direction
+    */
+    ScalarType GetExtentInWorld (unsigned int direction) const;
+
+    /**
+    * \brief Initializes the TimeGeometry
+    */
+    virtual void Initialize();
+
+    /**
+    * \brief Updates the geometry
+    */
+    void Update();
+
+    /**
+    * \brief Updates everything except the Bounding box
+    *
+    * This class should be overwritten by child classes.
+    * The method is called when Update() is required.
+    */
+    virtual void UpdateWithoutBoundingBox()
+    {};
+
+    /**
+    * \brief Executes the given operation on all time steps
+    */
+    virtual void ExecuteOperation(Operation *op);
+
+    virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
+
+  }; // end class TimeGeometry
+
+} // end namespace MITK
+#endif // TimeGeometry_h
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp b/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
deleted file mode 100644
index 2b29716886..0000000000
--- a/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
+++ /dev/null
@@ -1,422 +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 "mitkTimeSlicedGeometry.h"
-
-void mitk::TimeSlicedGeometry::UpdateInformation()
-{
-  if(m_TimeSteps==0) return;
-
-  unsigned long maxModifiedTime = 0, curModifiedTime;
-
-  mitk::ScalarType stmin, stmax;
-  stmin= ScalarTypeNumericTraits::NonpositiveMin();
-  stmax= ScalarTypeNumericTraits::max();
-
-  TimeBounds timeBounds;
-  timeBounds[0]=stmax; timeBounds[1]=stmin;
-
-  mitk::BoundingBox::Pointer boundingBox=mitk::BoundingBox::New();
-
-  mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
-
-  unsigned int t;
-
-  mitk::Geometry3D* geometry3d;
-  mitk::BoundingBox::ConstPointer nextBoundingBox;
-  mitk::BoundingBox::PointIdentifier pointid=0;
-
-  // Need to check for zero bounding boxes
-  mitk::ScalarType zeropoint[]={0,0,0,0,0,0};
-  BoundingBox::BoundsArrayType itkBoundsZero(zeropoint);
-
-  for(t=0; t < m_TimeSteps; ++t)
-  {
-    geometry3d = GetGeometry3D(t);
-    assert(geometry3d!=NULL);
-
-    curModifiedTime = geometry3d->GetMTime();
-    if(maxModifiedTime < curModifiedTime)
-      maxModifiedTime = curModifiedTime;
-
-    const TimeBounds & curTimeBounds = geometry3d->GetTimeBounds();
-    if((curTimeBounds[0] > stmin) && (curTimeBounds[0] < timeBounds[0]))
-      timeBounds[0] = curTimeBounds[0];
-    if((curTimeBounds[1] < stmax) && (curTimeBounds[1] > timeBounds[1]))
-      timeBounds[1] = curTimeBounds[1];
-
-    nextBoundingBox = geometry3d->GetBoundingBox();
-    assert(nextBoundingBox.IsNotNull());
-
-    // Only respect non-zero BBes
-    if (nextBoundingBox->GetBounds() == itkBoundsZero)
-    {
-      continue;
-    }
-
-    const mitk::BoundingBox::PointsContainer * nextPoints = nextBoundingBox->GetPoints();
-    if(nextPoints!=NULL)
-    {
-      mitk::BoundingBox::PointsContainer::ConstIterator pointsIt = nextPoints->Begin();
-
-      while (pointsIt != nextPoints->End() )
-      {
-        pointscontainer->InsertElement( pointid++, pointsIt->Value());
-        ++pointsIt;
-      }
-    }
-  }
-
-  if(!(timeBounds[0] < stmax))
-  {
-    timeBounds[0] = stmin;
-    timeBounds[1] = stmax;
-  }
-
-  m_TimeBounds = timeBounds;
-  assert(timeBounds[0]<=timeBounds[1]);
-
-  boundingBox->SetPoints(pointscontainer);
-
-  boundingBox->ComputeBoundingBox();
-
-  m_BoundingBox = boundingBox;
-
-  SetIndexToWorldTransform(GetGeometry3D(0)->GetIndexToWorldTransform());
-
-  if(this->GetMTime() < maxModifiedTime)
-    Modified();
-}
-
-mitk::Geometry3D* mitk::TimeSlicedGeometry::GetGeometry3D(int t) const
-{
-  mitk::Geometry3D::Pointer geometry3d = NULL;
-  if(IsValidTime(t))
-  {
-    geometry3d = m_Geometry3Ds[t];
-    //if (a) we don't have a Geometry3D stored for the requested time,
-    //(b) m_EvenlyTimed is activated and (c) the first geometry (t=0)
-    //is set, then we clone the geometry and set the m_TimeBounds accordingly.
-    if((m_EvenlyTimed) && (geometry3d.IsNull()))
-    {
-      const Geometry3D* firstgeometry=m_Geometry3Ds[0].GetPointer();
-
-      assert(firstgeometry != NULL);
-
-      mitk::Geometry3D::Pointer requestedgeometry;
-      requestedgeometry = dynamic_cast<Geometry3D*>(firstgeometry->Clone().GetPointer());
-      if ( requestedgeometry.IsNull() ) itkExceptionMacro("Geometry is NULL!");
-
-      TimeBounds timebounds = requestedgeometry->GetTimeBounds();
-      if(timebounds[1]<ScalarTypeNumericTraits::max())
-      {
-        mitk::ScalarType later = (timebounds[1]-timebounds[0])*t;
-        timebounds[0]+=later; timebounds[1]+=later;
-        requestedgeometry->SetTimeBounds(timebounds);
-      }
-
-      geometry3d = requestedgeometry;
-      m_Geometry3Ds[t] = geometry3d;
-    }
-  }
-  else
-    return NULL;
-  return geometry3d;
-}
-
-bool mitk::TimeSlicedGeometry::SetGeometry3D(mitk::Geometry3D* geometry3D, int t)
-{
-  if(IsValidTime(t))
-  {
-    m_Geometry3Ds[t]=geometry3D;
-    return true;
-  }
-  return false;
-}
-
-int mitk::TimeSlicedGeometry::MSToTimeStep(mitk::ScalarType time_in_ms) const
-{
-  if(time_in_ms < m_TimeBounds[0])
-    return -1;
-  if(time_in_ms >= m_TimeBounds[1])
-    return m_TimeSteps;
-  if(m_EvenlyTimed)
-  {
-    if(m_TimeBounds[0] == m_TimeBounds[1])
-      return 0;
-    if((m_TimeBounds[0]>ScalarTypeNumericTraits::NonpositiveMin()) && (m_TimeBounds[1]<ScalarTypeNumericTraits::max()))
-    {
-      return (int) ceil(((time_in_ms - m_TimeBounds[0])/(m_TimeBounds[1]-m_TimeBounds[0])*m_TimeSteps)-0.5);
-    }
-    return 0;
-  }
-  else
-  {
-    unsigned int t;
-    for ( t = 0; t < m_TimeSteps; ++t )
-    {
-      const TimeBounds& timeBounds = GetGeometry3D( t )->GetTimeBounds();
-      if( (timeBounds[0] <= time_in_ms) && (time_in_ms <= timeBounds[1]) )
-      {
-        return t;
-      }
-    }
-  }
-  return 0;
-}
-
-mitk::ScalarType mitk::TimeSlicedGeometry::TimeStepToMS(int timestep) const
-{
-  if(IsValidTime(timestep)==false)
-    return ScalarTypeNumericTraits::max();
-  if(m_EvenlyTimed)
-  {
-    if ( timestep == 0 )
-      return m_TimeBounds[0];
-    else
-    {
-      assert( ! (m_TimeBounds[0] == ScalarTypeNumericTraits::NonpositiveMin() && m_TimeBounds[1] == ScalarTypeNumericTraits::max() ) );
-      return ((mitk::ScalarType)timestep)/m_TimeSteps*(m_TimeBounds[1]-m_TimeBounds[0])+m_TimeBounds[0];
-    }
-  }
-  else
-  {
-    return GetGeometry3D(timestep)->GetTimeBounds()[0];
-  }
-}
-
-int mitk::TimeSlicedGeometry::TimeStepToTimeStep(
-  const mitk::TimeSlicedGeometry *referenceGeometry, int t) const
-{
-  int timeStep;
-  if ( referenceGeometry->GetTimeSteps() > 1 )
-  {
-    // referenceGeometry is nD+t
-    timeStep = this->MSToTimeStep( referenceGeometry->TimeStepToMS( t ) );
-  }
-  else
-  {
-    // referenceGEometry is nD (only one time step)
-    timeStep = 0;
-  }
-
-  return timeStep;
-}
-
-
-void mitk::TimeSlicedGeometry::InitializeEvenlyTimed(unsigned int timeSteps)
-{
-  Geometry3D::Pointer geometry3D = Geometry3D::New();
-  geometry3D->Initialize();
-  InitializeEvenlyTimed(geometry3D, timeSteps);
-}
-
-void mitk::TimeSlicedGeometry::InitializeEvenlyTimed(mitk::Geometry3D* geometry3D, unsigned int timeSteps)
-{
-  assert(geometry3D!=NULL);
-
-  geometry3D->Register();
-
-  InitializeEmpty(timeSteps);
-
-  AffineTransform3D::Pointer transform = AffineTransform3D::New();
-  transform->SetMatrix(geometry3D->GetIndexToWorldTransform()->GetMatrix());
-  transform->SetOffset(geometry3D->GetIndexToWorldTransform()->GetOffset());
-  SetIndexToWorldTransform(transform);
-
-  SetBounds(geometry3D->GetBounds());
-  SetGeometry3D(geometry3D, 0);
-  SetEvenlyTimed();
-
-  UpdateInformation();
-
-  SetFrameOfReferenceID(geometry3D->GetFrameOfReferenceID());
-  SetImageGeometry(geometry3D->GetImageGeometry());
-
-  geometry3D->UnRegister();
-}
-
-void mitk::TimeSlicedGeometry::InitializeEmpty(unsigned int timeSteps)
-{
-  m_IndexToWorldTransform = NULL;
-
-  Superclass::Initialize();
-
-  m_TimeSteps = timeSteps;
-
-  // initialize with empty geometries
-  Geometry3D::Pointer gnull=NULL;
-  m_Geometry3Ds.assign(m_TimeSteps, gnull);
-}
-
-void mitk::TimeSlicedGeometry::ExpandToNumberOfTimeSteps( unsigned int timeSteps )
-{
-  if( timeSteps <= m_TimeSteps ) return;
-
-  if(m_TimeSteps == 1)
-  {
-    Geometry3D* g3d = m_Geometry3Ds[0];
-    const TimeBounds & timeBounds = g3d->GetTimeBounds();
-    if( (timeBounds[0] == ScalarTypeNumericTraits::NonpositiveMin()) ||
-        (timeBounds[1]==ScalarTypeNumericTraits::max())
-      )
-    {
-      mitk::ScalarType timeBounds[] = {0.0, 1.0};
-      m_Geometry3Ds[0]->SetTimeBounds( timeBounds );
-    }
-  }
-
-  // Expand to Number of time steps; initialize with empty geometries
-  Geometry3D::Pointer gnull=NULL;
-  m_Geometry3Ds.resize(timeSteps, gnull);
-
-  m_TimeSteps = timeSteps;
-
-  UpdateInformation();
-}
-
-mitk::TimeSlicedGeometry::TimeSlicedGeometry() : m_TimeSteps(0), m_EvenlyTimed(false)
-{
-}
-
-mitk::TimeSlicedGeometry::TimeSlicedGeometry(const TimeSlicedGeometry& other) : Geometry3D(other), m_TimeSteps(other.m_TimeSteps), m_EvenlyTimed(other.m_EvenlyTimed)
-{
-  m_Geometry3Ds.resize(m_TimeSteps);
-  unsigned int t;
-  for(t=0; t<m_TimeSteps; ++t)
-  {
-    if(other.m_Geometry3Ds[t].IsNull())
-    {
-      assert(other.m_EvenlyTimed);
-      SetGeometry3D(NULL,t);
-    }
-    else
-    {
-      SetGeometry3D(dynamic_cast<Geometry3D*>(other.m_Geometry3Ds[t]->Clone().GetPointer()), t);
-    }
-  }
-}
-
-mitk::TimeSlicedGeometry::~TimeSlicedGeometry()
-{
-
-}
-
-void mitk::TimeSlicedGeometry::SetImageGeometry(const bool isAnImageGeometry)
-{
-  Superclass::SetImageGeometry(isAnImageGeometry);
-
-  mitk::Geometry3D* geometry3d;
-  unsigned int t;
-  for(t=0; t<m_TimeSteps; ++t)
-  {
-    geometry3d = m_Geometry3Ds[t];
-    if(geometry3d!=NULL)
-      geometry3d->SetImageGeometry(isAnImageGeometry);
-  }
-}
-
-
-void mitk::TimeSlicedGeometry::ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry)
-{
-  mitk::Geometry3D* geometry3d;
-  unsigned int t;
-  for(t=0; t<m_TimeSteps; ++t)
-  {
-    geometry3d = m_Geometry3Ds[t];
-    if(geometry3d!=NULL)
-      geometry3d->ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
-  }
-
-  Superclass::ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
-}
-
-
-void mitk::TimeSlicedGeometry::SetEvenlyTimed(bool on)
-{
-  m_EvenlyTimed = on;
-  Modified();
-}
-
-bool mitk::TimeSlicedGeometry::IsValidTime(int t) const
-{
-  return (t>=0) && (t< (int)m_TimeSteps);
-}
-
-bool mitk::TimeSlicedGeometry::IsValid() const
-{
-   return Superclass::IsValid() && (m_TimeSteps > 0);
-}
-
-
-void mitk::TimeSlicedGeometry::CopyTimes(const mitk::TimeSlicedGeometry* timeslicedgeometry, unsigned int t, unsigned int endtimeindex)
-{
-  if(endtimeindex >= timeslicedgeometry->GetTimeSteps())
-    endtimeindex = timeslicedgeometry->GetTimeSteps()-1;
-  if(endtimeindex >= this->GetTimeSteps())
-    endtimeindex = this->GetTimeSteps()-1;
-  for(; t <= endtimeindex; ++t)
-  {
-    mitk::Geometry3D* geometry3d = GetGeometry3D(t);
-    mitk::Geometry3D* othergeometry3d = timeslicedgeometry->GetGeometry3D(t);
-    assert((geometry3d!=NULL) && (othergeometry3d!=NULL));
-
-    geometry3d->SetTimeBounds(othergeometry3d->GetTimeBounds());
-
-  }
-
-  UpdateInformation();
-}
-
-itk::LightObject::Pointer mitk::TimeSlicedGeometry::InternalClone() const
-{
-  Self::Pointer newGeometry = new TimeSlicedGeometry(*this);
-  newGeometry->UnRegister();
-  return newGeometry.GetPointer();
-}
-
-
-
-void mitk::TimeSlicedGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
-{
-  //Superclass::PrintSelf(os,indent);
-  os << indent << " EvenlyTimed: " << m_EvenlyTimed << std::endl;
-  os << indent << " TimeSteps: " << m_TimeSteps << std::endl;
-
-  os << std::endl;
-  os << indent << " GetGeometry3D(0): ";
-  if(GetGeometry3D(0)==NULL)
-    os << "NULL" << std::endl;
-  else
-    GetGeometry3D(0)->Print(os, indent);
-}
-
-void mitk::TimeSlicedGeometry::ExecuteOperation(Operation* operation)
-{
-  // reach through to all time steps
-  for (std::vector<Geometry3D::Pointer>::iterator iter = m_Geometry3Ds.begin();
-    iter != m_Geometry3Ds.end();
-    ++iter)
-  {
-    (*iter)->ExecuteOperation(operation);
-  }
-
-  Geometry3D::ExecuteOperation(operation);
-
-  this->Modified();
-}
-
diff --git a/Core/Code/DataManagement/mitkTimeSlicedGeometry.h b/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
index 04ab86f89b..17939f43d0 100644
--- a/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
+++ b/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
@@ -1,182 +1,16 @@
-/*===================================================================
+#ifndef mitkTimeSlicedGeometry_h
+#define mitkTimeSlicedGeometry_h
 
-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 TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD
-#define TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD
-
-#include "mitkGeometry3D.h"
-
-namespace mitk {
-
-//##Documentation
-//## @brief Describes a geometry consisting of several geometries which
-//## exist at different times.
-//##
-//## The geometry contains m_TimeSteps geometries, which can be accessed
-//## using GetGeometry3D(int t). To convert between world-time in
-//## milliseconds and the integer timestep-number use MSToTimeStep.
-//## The hull (in space and time) of the TimeSlicedGeometry contains all
-//## contained geometries.
-//## @warning The hull (i.e., transform, bounding-box and
-//## time-bounds) is only guaranteed to be up-to-date after calling
-//## UpdateInformation().
-//##
-//## TimeSlicedGeometry and the associated Geometry3Ds 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().
-//##
-//## @ingroup Geometry
-class MITK_CORE_EXPORT TimeSlicedGeometry : public Geometry3D
+namespace mitk
 {
-public:
-  mitkClassMacro(TimeSlicedGeometry, Geometry3D);
-
-  itkNewMacro(Self);
-
-  //##Documentation
-  //## @brief Re-calculate the hull of the contained geometries.
-  //##
-  //## The transforms, bounding-box and time-bounds of this
-  //## geometry (stored in members of the super-class Geometry3D)
-  //## are re-calculated from the contained geometries.
-  void UpdateInformation();
-
-  //##Documentation
-  //## @brief Get the number of time-steps
-  itkGetConstMacro(TimeSteps, unsigned int);
-
-  //##Documentation
-  //## @brief Set/Get whether the TimeSlicedGeometry is evenly-timed (m_EvenlyTimed)
-  //##
-  //## If (a) we don't have a Geometry3D stored for the requested time,
-  //## (b) m_EvenlyTimed is activated and (c) the first geometry (t=0)
-  //## is set, then we clone the geometry and set the m_TimeBounds accordingly.
-  //## \sa GetGeometry3D
-   itkGetConstMacro(EvenlyTimed, bool);
-  virtual void SetEvenlyTimed(bool on = true);
-
-  //##Documentation
-  //## @brief Set the Geometry3D for time @a t
-  virtual bool SetGeometry3D(mitk::Geometry3D* geometry3D, int t);
-
-  //##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 Get the Geometry3D at time @a t
-  virtual mitk::Geometry3D* GetGeometry3D(int t) const;
-
-  //##Documentation
-  //## @brief Test whether @a t is a valid time step
-  virtual bool IsValidTime(int t) const;
-
-  //##Documentation
-  //## @brief Returns true if TimeSliceGeometry is valid
-  virtual bool IsValid() const;
-
-  //##Documentation
-  //## @brief Convert time in ms to a time step
-  virtual int MSToTimeStep(mitk::ScalarType time_in_ms) const;
-
-  //##Documentation
-  //## @brief Convert time step to time in ms
-  virtual mitk::ScalarType TimeStepToMS(int timestep) const;
-
-  //##Documentation
-  //## @brief Convert time step in the reference TimeSlicedGeometry to time step
-  //## in this TimeSlicedGeometry.
-  virtual int TimeStepToTimeStep(const mitk::TimeSlicedGeometry *referenceGeometry, int t) const;
-
-  //##Documentation
-  //## @brief Completely initialize this instance as evenly-timed with
-  //## \a timeSteps geometries of type Geometry3D, each initialized by
-  //## Geometry3D::Initialize().
-  virtual void InitializeEvenlyTimed(unsigned int timeSteps);
-
-  //##Documentation
-  //## @brief Completely initialize this instance as evenly-timed with
-  //## \a timeSteps geometries identical to the provided Geometry3D
-  //## except for the time bounds
-  virtual void InitializeEvenlyTimed(mitk::Geometry3D* geometry3D, unsigned int timeSteps);
-
-  //##Documentation
-  //## @brief Initialize this instance to contain \a timeSteps
-  //## geometries, but without setting them yet
-  virtual void InitializeEmpty(unsigned int timeSteps);
-
-  //##Documentation
-  //## @brief Expand the number of time steps contained
-  //## to \a timeSteps.
-  //##
-  //## New, additional time steps will be initialized empty.
-  //## Only enlargement of the time steps vector is intended and possible.
-  virtual void ExpandToNumberOfTimeSteps( unsigned int timeSteps );
-
-  virtual void SetImageGeometry(const bool isAnImageGeometry);
-
-  //##Documentation
-  //## @brief Copy the m_TimeBounds of the geometries contained
-  //## in timeslicedgeometry into the geometries contained in this
-  //## TimeSlicedGeometry object.
-  //##
-  //## Useful for initialization of the TimeSlicedGeometry of the
-  //## output in GenerateOutputInformation() methods of process objects,
-  //## see for example BoundingObjectCutter::GenerateOutputInformation().
-  //## @param t start time index
-  //## @param endtimeindex (endtimeindex) is the time index of
-  //## the last geometry whose time-bounds are copied. If
-  //## timeslicedgeometry or this TimeSlicedGeometry object does
-  //## not contain enough geometries, endtimeindex is reduced
-  //## appropriately.
-  void CopyTimes(const mitk::TimeSlicedGeometry* timeslicedgeometry, unsigned int t=0, unsigned int endtimeindex = itk::NumericTraits<unsigned int>::max());
-
-  //##Documentation
-  //## @brief duplicates the geometry
-  virtual itk::LightObject::Pointer InternalClone() const;
-  // muellerm, 18.1.13, method not implemented
-  //TimeSlicedGeometry::Pointer CloneCopy() const;
-  virtual void ExecuteOperation(Operation* operation);
-protected:
-  TimeSlicedGeometry();
-  TimeSlicedGeometry(const TimeSlicedGeometry& other);
-
-  virtual ~TimeSlicedGeometry();
-
-  virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
-
-  mutable std::vector<Geometry3D::Pointer> m_Geometry3Ds;
-
-  //##Documentation
-  //## @brief Number of time steps
-  unsigned int m_TimeSteps;
-
-  //##Documentation
-  //## @brief \a true in case the time steps have equal length
-  bool m_EvenlyTimed;
-
-  static const std::string EVENLY_TIMED;
-  static const std::string TIME_STEPS;
-};
+  /**
+  * \deprecatedSince{2013_06} Please use TimeGeometry instead. For more information see @TimeGeometryGuide@
+  */
+  DEPRECATED( class TimeSlicedGeometry;);
+}
 
-} // namespace mitk
+/*
+  * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
+  */
+#endif
 
-#endif /* TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/IO/mitkImageWriter.cpp b/Core/Code/IO/mitkImageWriter.cpp
index 03bdd61eea..acaa9c3829 100644
--- a/Core/Code/IO/mitkImageWriter.cpp
+++ b/Core/Code/IO/mitkImageWriter.cpp
@@ -1,457 +1,457 @@
 /*===================================================================
 
 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 "mitkItkPictureWrite.h"
 #include "mitkImage.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageReadAccessor.h"
 
 #include <itkImageIOBase.h>
 #include <itkImageIOFactory.h>
 
 
 mitk::ImageWriter::ImageWriter()
 {
   this->SetNumberOfRequiredInputs( 1 );
   m_MimeType = "";
   SetDefaultExtension();
 }
 
 mitk::ImageWriter::~ImageWriter()
 {
 }
 
 void mitk::ImageWriter::SetFileName(const char* fileName)
 {
   if ( fileName && ( fileName == this->m_FileName ) )
   {
     return;
   }
   if ( fileName )
   {
     this->m_FileName = fileName;
     this->m_FileNameWithoutExtension = this->m_FileName;
     this->m_Extension.clear();
     std::size_t pos = this->m_FileName.find_last_of("/\\");
     if (pos != std::string::npos)
     {
       std::size_t ppos = this->m_FileName.find_first_of('.', pos);
       if (ppos != std::string::npos)
       {
         this->m_FileNameWithoutExtension = this->m_FileName.substr(0, ppos);
         this->m_Extension = this->m_FileName.substr(ppos);
       }
     }
   }
   else
   {
     this->m_FileName.clear();
     this->m_FileNameWithoutExtension.clear();
     this->m_Extension.clear();
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetFileName(const std::string & fileName)
 {
   this->SetFileName( fileName.c_str() );
 }
 
 void mitk::ImageWriter::SetExtension(const char* extension)
 {
   if ( extension && ( extension == this->m_Extension ) )
   {
     return;
   }
   if ( extension )
   {
     this->m_Extension = extension;
     this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   }
   else
   {
     this->m_Extension.clear();
     this->m_FileName = this->m_FileNameWithoutExtension;
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetExtension(const std::string & extension)
 {
   this->SetFileName( extension.c_str() );
 }
 
 void mitk::ImageWriter::SetDefaultExtension()
 {
   this->m_Extension = ".mhd";
   this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   this->Modified();
 }
 
 #include <vtkConfigure.h>
 #include <vtkImageData.h>
 #include <vtkXMLImageDataWriter.h>
 static void writeVti(const char * filename, mitk::Image* image, int t=0)
 {
   vtkXMLImageDataWriter * vtkwriter = vtkXMLImageDataWriter::New();
   vtkwriter->SetFileName( filename );
   vtkwriter->SetInput(image->GetVtkImageData(t));
   vtkwriter->Write();
   vtkwriter->Delete();
 }
 
 #include <itkRGBAPixel.h>
 
 void mitk::ImageWriter::WriteByITK(mitk::Image* image, const std::string& fileName)
 {
   MITK_INFO << "Writing image: " << fileName << std::endl;
   // Pictures and picture series like .png are written via a different mechanism then volume images.
   // So, they are still multiplexed and thus not support vector images.
   if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos || fileName.find(".jpg") != std::string::npos || fileName.find(".bmp") != std::string::npos)
   {
     try
     {
       // switch processing of single/multi-component images
       if( image->GetPixelType(0).GetNumberOfComponents() == 1)
       {
         AccessByItk_1( image, _mitkItkPictureWrite, fileName );
       }
       else
       {
         AccessFixedPixelTypeByItk_1( image, _mitkItkPictureWriteComposite, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ , fileName);
       }
     }
     catch(itk::ExceptionObject &e)
     {
       std::cerr << "Caught " << e.what() << std::endl;
     }
     catch(std::exception &e)
     {
       std::cerr << "Caught std::exception " << e.what() << std::endl;
     }
 
     return;
   }
 
   // Implementation of writer using itkImageIO directly. This skips the use
   // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
 
   unsigned int dimension = image->GetDimension();
   unsigned int* dimensions = image->GetDimensions();
   mitk::PixelType pixelType = image->GetPixelType();
   mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
   mitk::Point3D origin = image->GetGeometry()->GetOrigin();
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( fileName.c_str(),
     itk::ImageIOFactory::WriteMode );
 
   if(imageIO.IsNull())
   {
     itkExceptionMacro(<< "Error: Could not create itkImageIO via factory for file " << fileName);
   }
 
   // Set the necessary information for imageIO
   imageIO->SetNumberOfDimensions(dimension);
   imageIO->SetPixelType( pixelType.GetPixelType() );
   imageIO->SetComponentType( pixelType.GetComponentType() < PixelComponentUserType ?
                              static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
                              itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
   imageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
 
   itk::ImageIORegion ioRegion( dimension );
 
   for(unsigned int i=0; i<dimension; i++)
   {
     imageIO->SetDimensions(i,dimensions[i]);
     imageIO->SetSpacing(i,spacing[i]);
     imageIO->SetOrigin(i,origin[i]);
 
     mitk::Vector3D direction;
     direction.SetVnlVector(image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
     vnl_vector< double > axisDirection(dimension);
     for(unsigned int j=0; j<dimension; j++)
     {
       axisDirection[j] = direction[j]/spacing[i];
     }
     imageIO->SetDirection( i, axisDirection );
 
     ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i) );
     ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i) );
   }
 
   //use compression if available
   imageIO->UseCompressionOn();
 
   imageIO->SetIORegion(ioRegion);
   imageIO->SetFileName(fileName);
 
   ImageReadAccessor imageAccess(image);
   imageIO->Write(imageAccess.GetData());
 }
 
 void mitk::ImageWriter::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 << "Could not set locale " << locale;
     }
   }
 
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   FILE* tempFile = fopen(m_FileName.c_str(),"w");
   if (tempFile==NULL)
   {
     itkExceptionMacro(<<"File location not writeable");
     return;
   }
   fclose(tempFile);
   remove(m_FileName.c_str());
 
   // Creating clone of input image, since i might change the geometry
   mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput())->Clone();
 
   // Check if geometry information will be lost
   if (input->GetDimension() == 2)
   {
      if (!input->GetGeometry()->Is2DConvertable())
      {
         MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
 
         // set matrix to identity
         mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
         affTrans->SetIdentity();
         mitk::Vector3D spacing = input->GetGeometry()->GetSpacing();
         mitk::Point3D origin = input->GetGeometry()->GetOrigin();
         input->GetGeometry()->SetIndexToWorldTransform(affTrans);
         input->GetGeometry()->SetSpacing(spacing);
         input->GetGeometry()->SetOrigin(origin);
      }
   }
 
   bool vti = (m_Extension.find(".vti") != std::string::npos);
 
   // If the extension is NOT .pic and NOT .nrrd and NOT .nii and NOT .nii.gz the following block is entered
   if ( m_Extension.find(".pic") == std::string::npos
        && m_Extension.find(".nrrd") == std::string::npos
        && m_Extension.find(".nii") == std::string::npos
        && m_Extension.find(".nii.gz") == std::string::npos
        )
   {
     if(input->GetDimension() > 3)
     {
       int t, timesteps;
 
       timesteps = input->GetDimension(3);
       ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
       timeSelector->SetInput(input);
       mitk::Image::Pointer image = timeSelector->GetOutput();
       for(t = 0; t < timesteps; ++t)
       {
         std::ostringstream filename;
         timeSelector->SetTimeNr(t);
         timeSelector->Update();
-        if(input->GetTimeSlicedGeometry()->IsValidTime(t))
+        if(input->GetTimeGeometry()->IsValidTimeStep(t))
         {
-          const mitk::TimeBounds& timebounds = input->GetTimeSlicedGeometry()->GetGeometry3D(t)->GetTimeBounds();
+          const mitk::TimeBounds& timebounds = input->GetTimeGeometry()->GetGeometryForTimeStep(t)->GetTimeBounds();
           filename <<  m_FileNameWithoutExtension << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
         }
         else
         {
-          itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of image " << filename << ".");
+          itkWarningMacro(<<"Error on write: TimeGeometry invalid of image " << filename << ".");
           filename <<  m_FileNameWithoutExtension << "_T" << t << m_Extension;
         }
         if ( vti )
         {
           writeVti(filename.str().c_str(), input, t);
         }
         else
         {
           WriteByITK(image, filename.str());
         }
       }
     }
     else if ( vti )
     {
       writeVti(m_FileName.c_str(), input);
     }
     else
     {
       WriteByITK(input, m_FileName);
     }
   }
   else
   {
     // use the PicFileWriter for the .pic data type
     if( m_Extension.find(".pic") != std::string::npos )
     {
 /*    PicFileWriter::Pointer picWriter = PicFileWriter::New();
     size_t found;
     found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
     if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
     {
       //if Extension not in Filename
       std::ostringstream filename;
       filename <<  m_FileName.c_str() << m_Extension;
       picWriter->SetFileName( filename.str().c_str() );
     }
     else
     {
       picWriter->SetFileName( m_FileName.c_str() );
     }
     picWriter->SetInputImage( input );
     picWriter->Write();
 */    }
 
     // use the ITK .nrrd Image writer
     if( m_Extension.find(".nrrd") != std::string::npos
         || m_Extension.find(".nii") != std::string::npos
         || m_Extension.find(".nii.gz") != std::string::npos
         )
     {
         WriteByITK(input, this->m_FileName);
     }
   }
   m_MimeType = "application/MITK.Pic";
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 }
 
 bool mitk::ImageWriter::CanWriteDataType( DataNode* input )
 {
   if ( input )
   {
     return this->CanWriteBaseDataType(input->GetData());
   }
   return false;
 }
 
 void mitk::ImageWriter::SetInput( DataNode* input )
 {
   if( input && CanWriteDataType( input ) )
     this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::Image*>( input->GetData() ) );
 }
 
 std::string mitk::ImageWriter::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".pic");
   possibleFileExtensions.push_back(".pic.gz");
   possibleFileExtensions.push_back(".bmp");
   possibleFileExtensions.push_back(".dcm");
   possibleFileExtensions.push_back(".DCM");
   possibleFileExtensions.push_back(".dicom");
   possibleFileExtensions.push_back(".DICOM");
   possibleFileExtensions.push_back(".gipl");
   possibleFileExtensions.push_back(".gipl.gz");
   possibleFileExtensions.push_back(".mha");
   possibleFileExtensions.push_back(".nii");
   possibleFileExtensions.push_back(".nii.gz");
   possibleFileExtensions.push_back(".nrrd");
   possibleFileExtensions.push_back(".nhdr");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".PNG");
   possibleFileExtensions.push_back(".spr");
   possibleFileExtensions.push_back(".mhd");
   possibleFileExtensions.push_back(".vtk");
   possibleFileExtensions.push_back(".vti");
   possibleFileExtensions.push_back(".hdr");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".tif");
   possibleFileExtensions.push_back(".jpg");
   return possibleFileExtensions;
 }
 
 std::string mitk::ImageWriter::GetFileExtension()
 {
   return m_Extension;
 }
 
 void mitk::ImageWriter::SetInput( mitk::Image* image )
 {
   this->ProcessObject::SetNthInput( 0, image );
 }
 
 const mitk::Image* mitk::ImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return static_cast< const mitk::Image * >( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 const char* mitk::ImageWriter::GetDefaultFilename()
 {
   return "Image.nrrd";
 }
 
 const char* mitk::ImageWriter::GetFileDialogPattern()
 {
   return "Image (*.bmp *.dcm *.DCM *.dicom *.DICOM *.gipl *.gipl.gz *.mha "
       "*.nii *.nii.gz *.nrrd *.nhdr *.png *.PNG *.spr *.mhd *.vtk *.vti *.hdr *.png "
       "*.tif *.jpg)";
 }
 
 const char *mitk::ImageWriter::GetDefaultExtension()
 {
   return ".nrrd";
 }
 
 bool mitk::ImageWriter::CanWriteBaseDataType(BaseData::Pointer data)
 {
   return dynamic_cast<mitk::Image*>( data.GetPointer() );
 }
 
 void mitk::ImageWriter::DoWrite(BaseData::Pointer data)
 {
   if (this->CanWriteBaseDataType(data))
   {
     this->SetInput(dynamic_cast<mitk::Image *>(data.GetPointer()));
     this->Update();
   }
 }
diff --git a/Core/Code/IO/mitkItkImageFileReader.cpp b/Core/Code/IO/mitkItkImageFileReader.cpp
index 64844dd321..904bbeb53e 100644
--- a/Core/Code/IO/mitkItkImageFileReader.cpp
+++ b/Core/Code/IO/mitkItkImageFileReader.cpp
@@ -1,205 +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 << "Could not set locale " << locale;
     }
   }
 
   mitk::Image::Pointer image = this->GetOutput();
 
   const unsigned int MINDIM = 2;
   const unsigned int MAXDIM = 4;
 
   MITK_INFO << "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;
 
   float 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 << "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->SetOrigin(origin);
   planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
   // re-initialize SlicedGeometry3D
   SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
   slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
   slicedGeometry->SetSpacing(spacing);
 
-  // re-initialize TimeSlicedGeometry
-  image->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, image->GetDimension(3));
+  MITK_INFO << slicedGeometry->GetCornerPoint(false,false,false);
+  MITK_INFO << 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 << "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 << "...finished!" << std::endl;
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "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/IO/mitkSurfaceVtkWriter.txx b/Core/Code/IO/mitkSurfaceVtkWriter.txx
index 172076c43d..15227dcd5c 100644
--- a/Core/Code/IO/mitkSurfaceVtkWriter.txx
+++ b/Core/Code/IO/mitkSurfaceVtkWriter.txx
@@ -1,174 +1,174 @@
 /*===================================================================
 
 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 "mitkSurfaceVtkWriter.h"
 #include <vtkConfigure.h>
 #include <vtkPolyData.h>
 #include <vtkLinearTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkErrorCode.h>
 
 #include <sstream>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <stdio.h>
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::SurfaceVtkWriter()
 : m_WriterWriteHasReturnValue( false )
 {
   this->SetNumberOfRequiredInputs( 1 );
 
   m_VtkWriter = vtkSmartPointer<VtkWriterType>::New();
 
   //enable to write ascii-formatted-file
   //m_VtkWriter->SetFileTypeToASCII();
 
   SetDefaultExtension(); // and information about the Writer's Write() method
 }
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::~SurfaceVtkWriter()
 {
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetDefaultExtension()
 {
   m_Extension = ".vtk";
 }
 
 template<class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::ExecuteWrite( VtkWriterType* vtkWriter )
 {
   if ( vtkWriter->Write() == 0 || vtkWriter->GetErrorCode() != 0 )
   {
     itkExceptionMacro(<<"Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(vtkWriter->GetErrorCode()) );
   }
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::GenerateData()
 {
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   mitk::Surface::Pointer input = const_cast<mitk::Surface*>(this->GetInput());
 
   vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   vtkPolyData * polyData;
   Geometry3D* geometry;
 
-  unsigned int t, timesteps = input->GetTimeSlicedGeometry()->GetTimeSteps();
+  unsigned int t, timesteps = input->GetTimeGeometry()->GetNumberOfTimeSteps();
 
   for(t = 0; t < timesteps; ++t)
   {
     // surfaces do not have to exist in all timeteps; therefor, only write valid surfaces
     if( input->GetVtkPolyData(t) == NULL ) continue;
 
     std::ostringstream filename;
     filename.imbue(::std::locale::classic());
     geometry = input->GetGeometry(t);
     if ( timesteps > 1 )
     {
-      if(input->GetTimeSlicedGeometry()->IsValidTime(t))
+      if(input->GetTimeGeometry()->IsValidTimeStep(t))
       {
         const TimeBounds& timebounds = geometry->GetTimeBounds();
         filename <<  m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
       }
       else
       {
-        itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of surface " << filename << ".");
+        itkWarningMacro(<<"Error on write: TimeGeometry invalid of surface " << filename << ".");
         filename <<  m_FileName.c_str() << "_T" << t << m_Extension;
       }
       m_VtkWriter->SetFileName(filename.str().c_str());
     }
     else
       m_VtkWriter->SetFileName(m_FileName.c_str());
 
     geometry->TransferItkToVtkTransform();
     transformPolyData->SetInput(input->GetVtkPolyData(t));
     transformPolyData->SetTransform(geometry->GetVtkTransform());
     transformPolyData->UpdateWholeExtent();
     polyData = transformPolyData->GetOutput();
 
     m_VtkWriter->SetInput(polyData);
 
     ExecuteWrite( m_VtkWriter );
   }
 
   m_MimeType = "application/MITK.Surface";
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( mitk::Surface* surface )
 {
   this->ProcessObject::SetNthInput( 0, surface );
 }
 
 template <class VTKWRITER>
 const mitk::Surface* mitk::SurfaceVtkWriter<VTKWRITER>::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return static_cast< const Surface * >( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 template <class VTKWRITER>
 bool mitk::SurfaceVtkWriter<VTKWRITER>::CanWriteDataType( DataNode* input )
 {
   if ( input )
   {
     BaseData* data = input->GetData();
     if ( data )
     {
       Surface::Pointer surface = dynamic_cast<Surface*>( data );
       if( surface.IsNotNull() )
       {
         SetDefaultExtension();
         return true;
       }
     }
   }
   return false;
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( DataNode* input )
 {
   if( input && CanWriteDataType( input ) )
     SetInput( dynamic_cast<Surface*>( input->GetData() ) );
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetFileExtension()
 {
   return m_Extension;
 }
diff --git a/Core/Code/Interactions/mitkAffineInteractor.cpp b/Core/Code/Interactions/mitkAffineInteractor.cpp
index b12be31427..f15650f790 100755
--- a/Core/Code/Interactions/mitkAffineInteractor.cpp
+++ b/Core/Code/Interactions/mitkAffineInteractor.cpp
@@ -1,381 +1,382 @@
 /*===================================================================
 
 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 "mitkAffineInteractor.h"
 #include "mitkInteractionConst.h"
 #include "mitkDataNode.h"
 #include "mitkGeometry3D.h"
 #include "mitkRotationOperation.h"
 #include "mitkPointOperation.h"
 #include "mitkPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkDisplayPositionEvent.h"
 #include "vtkTransform.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkProperties.h"
 #include <itkBoundingBox.h>
 #include <itkFixedArray.h>
 #include "mitkAction.h"
 
 //#include "mitkBoundingObject.h"
 #include "mitkRenderingManager.h"
 
 #include <math.h>
 
 #include <vtkWorldPointPicker.h>
 #include <vtkPicker.h>
 #include "mitkGlobalInteraction.h"
 #include "mitkFocusManager.h"
 #include "mitkEventMapper.h"
 #include "vtkProp3D.h"
 #include "mitkVtkInteractorCameraController.h"
 #include <vtkInteractorObserver.h>
 #include "vtkRenderer.h"
 #include "vtkCamera.h"
 #include <vtkInteractorObserver.h>
 
 #include <iostream>
 
 mitk::AffineInteractor::AffineInteractor(const char * type, DataNode* dataNode)
 : Interactor(type, dataNode)
 {
 }
 
 bool mitk::AffineInteractor::ExecuteAction(Action* action, mitk::StateEvent const* stateEvent)
 {
   bool ok = false;
 
-  TimeSlicedGeometry* inputtimegeometry = GetData()->GetTimeSlicedGeometry();
-  if (inputtimegeometry == NULL)
+  TimeGeometry* inputTimeGeometry = GetData()->GetTimeGeometry();
+  if (inputTimeGeometry == NULL)
     return false;
 
-  Geometry3D* geometry = inputtimegeometry->GetGeometry3D(m_TimeStep);
+  Geometry3D* geometry = inputTimeGeometry->GetGeometryForTimeStep(m_TimeStep);
 
   mitk::DisplayPositionEvent const *event = dynamic_cast <const mitk::DisplayPositionEvent *> (stateEvent->GetEvent());
   switch (action->GetActionId())
   {
   case AcCHECKELEMENT:
     {
       mitk::Point3D worldPoint = event->GetWorldPosition();
       /* now we have a worldpoint. check if it is inside our object and select/deselect it accordingly */
       mitk::BoolProperty::Pointer selected;
       mitk::ColorProperty::Pointer color;
       std::auto_ptr<StateEvent> newStateEvent;
 
       selected = dynamic_cast<mitk::BoolProperty*>(m_DataNode->GetProperty("selected"));
 
       if ( selected.IsNull() ) {
         selected = mitk::BoolProperty::New();
         m_DataNode->GetPropertyList()->SetProperty("selected", selected);
       }
 
       color = dynamic_cast<mitk::ColorProperty*>(m_DataNode->GetProperty("color"));
 
       if ( color.IsNull() ) {
         color = mitk::ColorProperty::New();
         m_DataNode->GetPropertyList()->SetProperty("color", color);
       }
 
       if (this->CheckSelected(worldPoint, m_TimeStep))
       {
         newStateEvent.reset(new mitk::StateEvent(EIDYES, stateEvent->GetEvent()));
         selected->SetValue(true);
         color->SetColor(1.0, 1.0, 0.0);
       }
       else
       {
         newStateEvent.reset(new mitk::StateEvent(EIDNO, stateEvent->GetEvent()));
         selected = mitk::BoolProperty::New(false);
         color->SetColor(0.0, 0.0, 1.0);
 
         /*
         mitk::BoundingObject* b = dynamic_cast<mitk::BoundingObject*>(m_DataNode->GetData());
         if(b != NULL)
         {
           color = (b->GetPositive())? mitk::ColorProperty::New(0.0, 0.0, 1.0) : mitk::ColorProperty::New(1.0, 0.0, 0.0);  // if deselected, a boundingobject is colored according to its positive/negative state
         }
         else
           color = mitk::ColorProperty::New(1.0, 1.0, 1.0);   // if deselcted and no bounding object, color is white
         */
       }
 
       /* write new state (selected/not selected) to the property */
       this->HandleEvent( newStateEvent.get() );
       ok = true;
       break;
     }
   case AcADD:
     {
       mitk::Point3D worldPoint = event->GetWorldPosition();
       std::auto_ptr<StateEvent> newStateEvent;
       if (this->CheckSelected(worldPoint, m_TimeStep))
       {
         newStateEvent.reset(new mitk::StateEvent(EIDYES, event));
         m_DataNode->GetPropertyList()->SetProperty("selected", mitk::BoolProperty::New(true));  // TODO: Generate an Select Operation and send it to the undo controller ?
       }
       else  // if not selected, do nothing (don't deselect)
       {
         newStateEvent.reset(new mitk::StateEvent(EIDNO, event));
       }
       //call HandleEvent to leave the guard-state
       this->HandleEvent( newStateEvent.get() );
       ok = true;
       break;
     }
   case AcTRANSLATESTART:
   case AcROTATESTART:
   case AcSCALESTART:
     {
       m_LastMousePosition = event->GetWorldPosition();
       ok = true;
       break;
     }
   case AcTRANSLATE:
     {
       mitk::Point3D newPosition;
       newPosition = event->GetWorldPosition();
       newPosition -=  m_LastMousePosition.GetVectorFromOrigin();        // compute difference between actual and last mouse position
       m_LastMousePosition = event->GetWorldPosition();               // save current mouse position as last position
 
       /* create operation with position difference */
       mitk::PointOperation* doOp = new mitk::PointOperation(OpMOVE, newPosition, 0); // Index is not used here
       if (m_UndoEnabled)  //write to UndoMechanism
       {
         mitk::Point3D oldPosition=geometry->GetCornerPoint(0);
 
         PointOperation* undoOp = new mitk::PointOperation(OpMOVE, oldPosition, 0);
         OperationEvent *operationEvent = new OperationEvent(geometry, doOp, undoOp);
         m_UndoController->SetOperationEvent(operationEvent);
       }
       /* execute the Operation */
       geometry->ExecuteOperation(doOp);
 
       if (!m_UndoEnabled)
         delete doOp;
 
       ok = true;
       break;
     }
   case AcTRANSLATEEND:
     {
       m_UndoController->SetOperationEvent(new UndoStackItem("Move object"));
       m_DataNode->InvokeEvent(TranslateEvent());
       break;
     }
   case AcROTATE:
     {
       mitk::Point3D p = event->GetWorldPosition();
 
       mitk::Vector3D newPosition = p.GetVectorFromOrigin();
 
       mitk::Point3D dataPosition = geometry->GetCenter();
 
       newPosition = newPosition - dataPosition.GetVectorFromOrigin();  // calculate vector from center of the data object to the current mouse position
 
       mitk::Vector3D startPosition = m_LastMousePosition.GetVectorFromOrigin() - dataPosition.GetVectorFromOrigin();  // calculate vector from center of the data object to the last mouse position
 
       /* calculate rotation axis (by calculating the cross produkt of the vectors) */
       mitk::Vector3D rotationaxis;
       rotationaxis[0] =  startPosition[1] * newPosition[2] - startPosition[2] * newPosition[1];
       rotationaxis[1] =  startPosition[2] * newPosition[0] - startPosition[0] * newPosition[2];
       rotationaxis[2] =  startPosition[0] * newPosition[1] - startPosition[1] * newPosition[0];
 
       /* calculate rotation angle in degrees */
       mitk::ScalarType angle = atan2((mitk::ScalarType)rotationaxis.GetNorm(), (mitk::ScalarType) (newPosition * startPosition)) * (180/vnl_math::pi);
       m_LastMousePosition = p; // save current mouse position as last mouse position
 
       /* create operation with center of rotation, angle and axis and send it to the geometry and Undo controller */
       mitk::RotationOperation* doOp = new mitk::RotationOperation(OpROTATE, dataPosition, rotationaxis, angle);
 
       if (m_UndoEnabled)  //write to UndoMechanism
       {
         RotationOperation* undoOp = new mitk::RotationOperation(OpROTATE, dataPosition, rotationaxis, -angle);
         OperationEvent *operationEvent = new OperationEvent(geometry, doOp, undoOp);
         m_UndoController->SetOperationEvent(operationEvent);
       }
       /* execute the Operation */
       geometry->ExecuteOperation(doOp);
 
       if(!m_UndoEnabled)
         delete doOp;
 
       ok = true;
       break;
     }
   case AcROTATEEND:
     {
       m_UndoController->SetOperationEvent(new UndoStackItem("Rotate object"));
       m_DataNode->InvokeEvent(RotateEvent());
       break;
     }
   case AcSCALE:
     {
       mitk::Point3D p = event->GetWorldPosition();
 
       mitk::Vector3D v = p - m_LastMousePosition;
       /* calculate scale changes */
       mitk::Point3D newScale;
       newScale[0] = (geometry->GetAxisVector(0) * v) / geometry->GetExtentInMM(0);  // Scalarprodukt of normalized Axis
       newScale[1] = (geometry->GetAxisVector(1) * v) / geometry->GetExtentInMM(1);  // and direction vector of mouse movement
       newScale[2] = (geometry->GetAxisVector(2) * v) / geometry->GetExtentInMM(2);  // is the length of the movement vectors
       // projection onto the axis
       /* convert movement to local object coordinate system and mirror it to the positive quadrant */
       Vector3D start;
       Vector3D end;
       mitk::ScalarType convert[3];
       itk2vtk(m_LastMousePosition, convert);
       geometry->GetVtkTransform()->GetInverse()->TransformPoint(convert, convert);  // transform start point to local object coordinates
       start[0] = fabs(convert[0]);  start[1] = fabs(convert[1]);  start[2] = fabs(convert[2]);  // mirror it to the positive quadrant
       itk2vtk(p, convert);
       geometry->GetVtkTransform()->GetInverse()->TransformPoint(convert, convert);  // transform end point to local object coordinates
       end[0] = fabs(convert[0]);  end[1] = fabs(convert[1]);  end[2] = fabs(convert[2]);  // mirror it to the positive quadrant
 
       /* check if mouse movement is towards or away from the objects axes and adjust scale factors accordingly */
       Vector3D vLocal = start - end;
       newScale[0] = (vLocal[0] > 0.0) ? -fabs(newScale[0]) : +fabs(newScale[0]);
       newScale[1] = (vLocal[1] > 0.0) ? -fabs(newScale[1]) : +fabs(newScale[1]);
       newScale[2] = (vLocal[2] > 0.0) ? -fabs(newScale[2]) : +fabs(newScale[2]);
 
       m_LastMousePosition = p;  // update lastPosition for next mouse move
 
       /* generate Operation and send it to the receiving geometry */
       PointOperation* doOp = new mitk::PointOperation(OpSCALE, newScale, 0); // Index is not used here
       if (m_UndoEnabled)  //write to UndoMechanism
       {
         mitk::Point3D oldScaleData;
         oldScaleData[0] = -newScale[0];
         oldScaleData[1] = -newScale[1];
         oldScaleData[2] = -newScale[2];
 
         PointOperation* undoOp = new mitk::PointOperation(OpSCALE, oldScaleData, 0);
         OperationEvent *operationEvent = new OperationEvent(geometry, doOp, undoOp);
         m_UndoController->SetOperationEvent(operationEvent);
       }
       /* execute the Operation */
       geometry->ExecuteOperation(doOp);
 
       if(!m_UndoEnabled)
         delete doOp;
 
       /* Update Volume Property with new value */
       /*
       mitk::BoundingObject* b = dynamic_cast<mitk::BoundingObject*>(m_DataNode->GetData());
       if (b != NULL)
       {
         m_DataNode->GetPropertyList()->SetProperty("volume", FloatProperty::New(b->GetVolume()));
         //MITK_INFO << "Volume of Boundingobject is " << b->GetVolume()/1000.0 << " ml" << std::endl;
       }
       */
       ok = true;
       break;
     }
   case AcSCALEEND:
     {
       m_UndoController->SetOperationEvent(new UndoStackItem("Scale object"));
       m_DataNode->InvokeEvent(ScaleEvent());
       break;
     }
   default:
     ok = Superclass::ExecuteAction(action, stateEvent);//, objectEventId, groupEventId);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   return ok;
 }
 
 bool mitk::AffineInteractor::CheckSelected(const mitk::Point3D& worldPoint, int timestep )
 {
   bool selected = false;
   if (m_DataNode->GetBoolProperty("selected", selected) == false)        // if property does not exist
     m_DataNode->SetProperty("selected", mitk::BoolProperty::New(false));  // create it
 
   // check if mouseclick has hit the object
   /*
   mitk::BoundingObject::Pointer boundingObject = dynamic_cast<mitk::BoundingObject*>(m_DataNode->GetData());
   if(boundingObject.IsNotNull())  // if it is a bounding object, use its inside function for exact hit calculation
   {
     selected = boundingObject->IsInside(worldPoint); // check if point is inside the object
   }
   else    // use the data objects bounding box to determine if hit
   */
   {
-    const Geometry3D* geometry = GetData()->GetUpdatedTimeSlicedGeometry()->GetGeometry3D( timestep );
+    GetData()->GetTimeGeometry()->Update();
+    const Geometry3D* geometry = GetData()->GetGeometry( timestep );
     selected = geometry->IsInside(worldPoint);
   }
   return selected;
 }
 
 bool mitk::AffineInteractor::ConvertDisplayEventToWorldPosition(mitk::DisplayPositionEvent const* displayEvent, mitk::Point3D& worldPoint)
 {
   mitk::Point2D displayPoint = displayEvent->GetDisplayPosition();
   /* Copied from vtk Sphere widget */
   double focalPoint[4], position[4];
   double z;
 
   FocusManager::FocusElement* fe = mitk::GlobalInteraction::GetInstance()->GetFocus();
   mitk::VtkPropRenderer* glRenderer = dynamic_cast<mitk::VtkPropRenderer*>( fe );
   if ( glRenderer == NULL )
   {
     return false;
   }
 
   vtkRenderer *renderer = glRenderer->GetVtkRenderer();
   vtkCamera *camera = renderer->GetActiveCamera();
   if ( !camera )
   {
     return false;
   }
   // Compute the two points defining the motion vector
   camera->GetFocalPoint(focalPoint);
   //this->ComputeWorldToDisplay(focalPoint[0], focalPoint[1], focalPoint[2], focalPoint);
   renderer->SetWorldPoint(focalPoint[0], focalPoint[1], focalPoint[2], 1.0);
   renderer->WorldToDisplay();
   renderer->GetDisplayPoint(focalPoint);
   z = focalPoint[2];
   //      this->ComputeDisplayToWorld(displayPoint.x, displayPoint.y, z, position);
   renderer->SetDisplayPoint(displayPoint[0], displayPoint[1], z);
   renderer->DisplayToWorld();
   renderer->GetWorldPoint(position);
   if (position[3])
   {
     worldPoint[0] = position[0] / position[3];
     worldPoint[1] = position[1] / position[3];
     worldPoint[2] = position[2] / position[3];
     position[3] = 1.0;
   }
   else
   {
     worldPoint[0] = position[0];
     worldPoint[1] = position[1];
     worldPoint[2] = position[2];
   }
   return true;
 }
 
 float mitk::AffineInteractor::CanHandleEvent( StateEvent const* stateEvent ) const
 {
   float jd = 0.0f;
 
   if ( stateEvent->GetEvent()->GetSender()->GetMapperID() == mitk::BaseRenderer::Standard3D )
   {
     MITK_DEBUG << "Sorry, mitkAffineInteractor does not support interaction in a 3D view at the moment.";
     return jd;
   }
 
   return Superclass::CanHandleEvent( stateEvent );
 }
diff --git a/Core/Code/Interactions/mitkInteractor.cpp b/Core/Code/Interactions/mitkInteractor.cpp
index e498687fdd..f9b27c0f76 100755
--- a/Core/Code/Interactions/mitkInteractor.cpp
+++ b/Core/Code/Interactions/mitkInteractor.cpp
@@ -1,297 +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)
   {
-    const BoundingBox *bBox = GetData()->GetUpdatedTimeSlicedGeometry()->GetBoundingBox();
-    if (bBox == NULL)
-      return 0;
-
 
     DisplayPositionEvent const  *event = dynamic_cast <const DisplayPositionEvent *> (stateEvent->GetEvent());
     if (event != NULL)
     {
       //transforming the world position to local coordinate system
       Point3D point;
-      GetData()->GetTimeSlicedGeometry()->WorldToIndex(event->GetWorldPosition(), 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
         unsigned int currentTimeStep = sender->GetTimeStep();
         if (currentTimeStep != m_TimeStep)
           this->UpdateTimeStep(currentTimeStep);
       }
     }
   }
   return Superclass::HandleEvent(stateEvent);
 }
 
diff --git a/Core/Code/Interactions/mitkMoveBaseDataInteractor.cpp b/Core/Code/Interactions/mitkMoveBaseDataInteractor.cpp
index 21a2c4cd78..b3fa20353f 100644
--- a/Core/Code/Interactions/mitkMoveBaseDataInteractor.cpp
+++ b/Core/Code/Interactions/mitkMoveBaseDataInteractor.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 "mitkMoveBaseDataInteractor.h"
 #include "mitkInteractionConst.h"
 #include <mitkDataNode.h>
 #include "mitkDisplayPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkProperties.h"
 
 //for an temporary update
 #include "mitkRenderingManager.h"
 
 //## Default Constructor
 mitk::MoveBaseDataInteractor
 ::MoveBaseDataInteractor(const char * type, DataNode* dataNode)
 :Interactor(type, dataNode)
 {
     //define the colors for selected/deselected state
     m_DataNode->AddProperty( "MovingInteractor.SelectedColor", ColorProperty::New(0.0,1.0,0.0) );
     m_DataNode->AddProperty( "MovingInteractor.DeselectedColor", ColorProperty::New(0.0,0.0,1.0) );
     //save the previous color of the node, in order to restore it after the interactor is destroyed
     mitk::ColorProperty::Pointer priorColor = dynamic_cast<mitk::ColorProperty*>(m_DataNode->GetProperty("color"));
     if ( priorColor.IsNotNull() )
     {
         mitk::ColorProperty::Pointer tmpCopyOfPriorColor = mitk::ColorProperty::New();
         tmpCopyOfPriorColor->SetColor( priorColor->GetColor() );
         m_DataNode->AddProperty( "MovingInteractor.PriorColor", tmpCopyOfPriorColor );
     }
 }
 
 mitk::MoveBaseDataInteractor::~MoveBaseDataInteractor()
 {
     mitk::ColorProperty::Pointer color = dynamic_cast<mitk::ColorProperty*>(m_DataNode->GetProperty("MovingInteractor.PriorColor"));
     if ( color.IsNotNull() )
     {
         m_DataNode->GetPropertyList()->SetProperty("color", color);
     }
 
     m_DataNode->GetPropertyList()->DeleteProperty("MovingInteractor.SelectedColor");
     m_DataNode->GetPropertyList()->DeleteProperty("MovingInteractor.DeselectedColor");
     m_DataNode->GetPropertyList()->DeleteProperty("MovingInteractor.PriorColor");
     //update rendering
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 bool mitk::MoveBaseDataInteractor::ExecuteAction( Action* action, mitk::StateEvent const* stateEvent )
 {
   bool ok = false;
 
   /*Each case must watch the type of the event!*/
   switch (action->GetActionId())
   {
   case AcDONOTHING:
     ok = true;
     break;
   case AcCHECKELEMENT:
     /*
     * picking: Answer the question if the given position within stateEvent is close enough to select an object
     * send yes if close enough and no if not picked
     */
     {
       mitk::DisplayPositionEvent const *posEvent = dynamic_cast <const mitk::DisplayPositionEvent *> (stateEvent->GetEvent());
       if (posEvent == NULL)
       {
         MITK_WARN<<"Wrong usage of mitkMoveBaseDataInteractor! Aborting interaction!\n";
         return false;
       }
 
       mitk::Point3D worldPoint = posEvent->GetWorldPosition();
       /* now we have a worldpoint. check if it is inside our object and select/deselect it accordingly */
 
       std::auto_ptr<StateEvent> newStateEvent;
-      const Geometry3D* geometry = GetData()->GetUpdatedTimeSlicedGeometry()->GetGeometry3D( m_TimeStep );
+      const Geometry3D* geometry = GetData()->GetUpdatedTimeGeometry()->GetGeometryForTimeStep( m_TimeStep );
       if (geometry->IsInside(worldPoint))
         newStateEvent.reset(new mitk::StateEvent(EIDYES, stateEvent->GetEvent()));
       else
         newStateEvent.reset(new mitk::StateEvent(EIDNO, stateEvent->GetEvent()));
 
       /* write new state (selected/not selected) to the property */
       this->HandleEvent( newStateEvent.get() );
 
     ok = true;
     break;
     }
   case AcSELECT:
     // select the data
     {
       mitk::BoolProperty::Pointer selected = dynamic_cast<mitk::BoolProperty*>(m_DataNode->GetProperty("selected"));
       if ( selected.IsNull() )
       {
         selected = mitk::BoolProperty::New();
         m_DataNode->GetPropertyList()->SetProperty("selected", selected);
       }
 
       mitk::ColorProperty::Pointer selectedColor = dynamic_cast<mitk::ColorProperty*>(m_DataNode->GetProperty("MovingInteractor.SelectedColor"));
       if ( selectedColor.IsNotNull() )
       {
         m_DataNode->GetPropertyList()->SetProperty("color", selectedColor);
       }
       selected->SetValue(true);
 
       //update rendering
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
       ok = true;
       break;
     }
   case AcDESELECT:
     //deselect the data
     {
       mitk::BoolProperty::Pointer selected = dynamic_cast<mitk::BoolProperty*>(m_DataNode->GetProperty("selected"));
       if ( selected.IsNull() )
       {
         selected = mitk::BoolProperty::New();
         m_DataNode->GetPropertyList()->SetProperty("selected", selected);
       }
 
       mitk::ColorProperty::Pointer deselectedColor =
               dynamic_cast<mitk::ColorProperty*>(m_DataNode->GetProperty("MovingInteractor.DeselectedColor"));
       if ( deselectedColor.IsNotNull() )
       {
         m_DataNode->GetPropertyList()->SetProperty("color", deselectedColor);
       }
 
       selected = mitk::BoolProperty::New(false);
 
       //update rendering
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
       ok = true;
       break;
     }
   case AcMOVE:
     {
       //modify Geometry from data as given in parameters or in event
       mitk::IntProperty* xP = dynamic_cast<mitk::IntProperty*>(action->GetProperty("DIRECTION_X"));
       mitk::IntProperty* yP = dynamic_cast<mitk::IntProperty*>(action->GetProperty("DIRECTION_Y"));
       mitk::IntProperty* zP = dynamic_cast<mitk::IntProperty*>(action->GetProperty("DIRECTION_Z"));
       if (xP == NULL || yP == NULL || zP == NULL)
       {
         MITK_WARN<<"No properties returned\n!";
         return false;
       }
       mitk::Vector3D movementVector;
       movementVector.SetElement(0, (float) xP->GetValue());
       movementVector.SetElement(1, (float) yP->GetValue());
       movementVector.SetElement(2, (float) zP->GetValue());
 
-      Geometry3D* geometry = m_DataNode->GetData()->GetUpdatedTimeSlicedGeometry()->GetGeometry3D( m_TimeStep );
+      Geometry3D* geometry = m_DataNode->GetData()->GetUpdatedTimeGeometry()->GetGeometryForTimeStep( m_TimeStep );
       geometry->Translate(movementVector);
 
       // indicate modification of data tree node
       m_DataNode->Modified();
 
       //update rendering
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
   default:
     return Superclass::ExecuteAction( action, stateEvent );
   }
 
   return ok;
 }
 
 /**
 \example mitkMoveBaseDataInteractor.cpp
  * This is an example of how to implement a new Interactor.
  * See more details about this example in tutorial Step10.
  */
diff --git a/Core/Code/Interactions/mitkPointSetInteractor.cpp b/Core/Code/Interactions/mitkPointSetInteractor.cpp
index 1fbee816a6..d3c4695f15 100644
--- a/Core/Code/Interactions/mitkPointSetInteractor.cpp
+++ b/Core/Code/Interactions/mitkPointSetInteractor.cpp
@@ -1,1119 +1,1119 @@
 /*===================================================================
 
 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 "mitkPointSetInteractor.h"
 #include "mitkPointOperation.h"
 #include "mitkPositionEvent.h"
 #include "mitkPointSet.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"
 
 
 //how precise must the user pick the point
 //default value
 const int PRECISION = 5;
 
 mitk::PointSetInteractor
 ::PointSetInteractor(const char * type, DataNode* dataNode, int n)
 :Interactor(type, dataNode), m_Precision(PRECISION), m_N(n)
 {
   if (m_N==0)
   {
     STATEMACHINE_WARN<<"Instanciation of PointSetInteractor which takes care of 0 points does't make sense!\n";
     STATEMACHINE_WARN<<"Setting number of points to 1!\n";
     m_N = 1;
   }
 
   m_LastPoint.Fill(0);
   m_SumVec.Fill(0);
   this->InitAccordingToNumberOfPoints();
 }
 
 mitk::PointSetInteractor::~PointSetInteractor()
 {
 }
 
 //##Documentation
 //## overwritten cause this class can handle it better!
 float mitk::PointSetInteractor::CanHandleEvent(StateEvent const* stateEvent) const
 {
   float returnValue = 0.0;
   //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;}
   }
   //on MouseMove do nothing!
   if (stateEvent->GetEvent()->GetType() == mitk::Type_MouseMove)
   {return 0;}
   //get the time of the sender to look for the right transition.
   mitk::BaseRenderer* sender = stateEvent->GetEvent()->GetSender();
   if (sender != NULL)
   {
-    unsigned int timeStep = sender->GetTimeStep(m_DataNode->GetData());
+    int timeStep = sender->GetTimeStep(m_DataNode->GetData());
     //if the event can be understood and if there is a transition waiting for that event
     mitk::State const* state = this->GetCurrentState(timeStep);
     if (state!= NULL)
       if (state->GetTransition(stateEvent->GetId())!=NULL)
         returnValue = 0.5;//it can be understood
     mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
     if ( pointSet != NULL )
     {
       //if we have one point or more, then check if the have been picked
       if ( (pointSet->GetSize( timeStep ) > 0)
         && (pointSet->SearchPoint(
         disPosEvent->GetWorldPosition(), m_Precision, timeStep) > -1) )
       {returnValue = 1.0;}
     }
   }
   return returnValue;
 }
 
 //TODO: add a new calculation of precision here! Input: StateEvent and Precision
 //the method does a 2D picking with display coordinates and display geometry.
 //Here the distance between the mouse position and the point is not as relative anymore!
 //float mitk::PointSetInteractor::CalculatePrecision(float precision, mitk::StateEvent stateEvent)
 //{
 //  mitk::BaseRenderer *renderer = stateEvent->GetEvent()->GetSender();
 //  if (renderer != NULL)
 //  {
 //    const mitk::DisplayGeometry* displayGeometry = renderer->GetDisplayGeometry();
 //    if (displayGeometry != NULL)
 //      displayGeometry->WorldToDisplay(, lineFrom);
 //    precision =
 //  }
 //
 //  return precision;
 //
 //}
 
 void mitk::PointSetInteractor::UnselectAll( unsigned int timeStep, ScalarType timeInMS )
 {
   mitk::PointSet *pointSet =
     dynamic_cast<mitk::PointSet*>( m_DataNode->GetData() );
   if ( pointSet == NULL )
   {
     return;
   }
 
   mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet( timeStep );
   if ( itkPointSet == NULL )
   {
     return;
   }
 
   mitk::PointSet::PointsContainer::Iterator it, end;
   end = itkPointSet->GetPoints()->End();
 
   for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
   {
     int position = it->Index();
     PointSet::PointDataType pointData = {0, false, PTUNDEFINED};
     itkPointSet->GetPointData( position, &pointData );
 
     //then declare an operation which unselects this point;
     //UndoOperation as well!
     if ( pointData.selected )
     {
       mitk::Point3D noPoint;
       noPoint.Fill( 0 );
       mitk::PointOperation *doOp = new mitk::PointOperation(
         OpDESELECTPOINT, timeInMS, noPoint, position);
 
       if ( m_UndoEnabled )
       {
         mitk::PointOperation *undoOp =
           new mitk::PointOperation(OpSELECTPOINT, timeInMS, noPoint, position);
         OperationEvent *operationEvent =
           new OperationEvent( pointSet, doOp, undoOp );
 
         m_UndoController->SetOperationEvent( operationEvent );
       }
 
       pointSet->ExecuteOperation( doOp );
 
       if ( !m_UndoEnabled )
         delete doOp;
     }
   }
 }
 
 void mitk::PointSetInteractor::SelectPoint( int position, unsigned int timeStep, ScalarType timeInMS )
 {
   mitk::PointSet *pointSet = dynamic_cast< mitk::PointSet * >(
     m_DataNode->GetData() );
 
   //if List is empty, then no select of a point can be done!
   if ( (pointSet == NULL) || (pointSet->GetSize( timeStep ) <= 0) )
   {
     return;
   }
 
   //dummyPoint... not needed anyway
   mitk::Point3D noPoint;
   noPoint.Fill(0);
 
   mitk::PointOperation *doOp = new mitk::PointOperation(
     OpSELECTPOINT, timeInMS, noPoint, position);
 
   if ( m_UndoEnabled )
   {
     mitk::PointOperation* undoOp = new mitk::PointOperation(
       OpDESELECTPOINT, timeInMS, noPoint, position);
 
     OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
     m_UndoController->SetOperationEvent(operationEvent);
   }
 
   pointSet->ExecuteOperation( doOp );
 
   if ( !m_UndoEnabled )
     delete doOp;
 
 }
 
 
 bool mitk::PointSetInteractor::ExecuteAction( Action* action, mitk::StateEvent const* stateEvent )
 {
   bool ok = false;//for return type bool
 
   //checking corresponding Data; has to be a PointSet or a subclass
   mitk::PointSet* pointSet =
     dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
   if ( pointSet == NULL )
   {
     return false;
   }
 
   //get the timestep to support 3D+T
   const mitk::Event *theEvent = stateEvent->GetEvent();
   mitk::ScalarType timeInMS = 0.0;
 
   //check if the current timestep has to be changed
   if ( theEvent )
   {
     if (theEvent->GetSender() != NULL)
     {
       //additionaly to m_TimeStep we need timeInMS to satisfy the execution of the operations
       timeInMS = theEvent->GetSender()->GetTime();
     }
   }
 
   //for reading on the points, Id's etc
   mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet( m_TimeStep );
   if ( itkPointSet == NULL )
   {
     return false;
   }
 
   mitk::PointSet::PointsContainer *points = itkPointSet->GetPoints();
 
   /*Each case must watch the type of the event!*/
   switch (action->GetActionId())
   {
   case AcDONOTHING:
     ok = true;
     break;
   case AcCHECKOPERATION:
     //to check if the given Event is a DisplayPositionEvent.
     {
       mitk::DisplayPositionEvent const *dispPosEvent =
         dynamic_cast <const mitk::DisplayPositionEvent *> (
           stateEvent->GetEvent());
 
       if (dispPosEvent != NULL)
       {
         mitk::StateEvent newStateEvent(EIDYES, stateEvent->GetEvent());
         this->HandleEvent( &newStateEvent );
       }
       else
       {
         mitk::StateEvent newStateEvent(EIDNO, stateEvent->GetEvent());
         this->HandleEvent( &newStateEvent );
       }
       ok = true;
       break;
     }
 
   case AcADDPOINT:
     // Declare two operations: one for the selected state: deselect the last
     // one selected and select the new one the other operation is the add
     // operation: There the first empty place have to be found and the new
     // point inserted into that space
     {
       mitk::DisplayPositionEvent const *posEvent =
         dynamic_cast < const mitk::DisplayPositionEvent * >
           (stateEvent->GetEvent());
 
       // Check if it is a DisplayEvent thrown in a 3D window. Then the
       // z-information is missing. Returning false might end in the state
       // full, but the last point couldn't be added, so the set wouldn't be
       // full. So a extra Action that checks the operationtype has been added.
       if ( posEvent == NULL )
       {
         return false;
       }
 
       mitk::Point3D itkPoint;
       itkPoint = posEvent->GetWorldPosition();
 
       // undo-supported deselect of all points in the DataList; if List is
       // empty, then nothing will be unselected
       this->UnselectAll( m_TimeStep, timeInMS );
 
       // find the position, the point is to be added to: first entry with
       // empty index. If the Set is empty, then start with 0. if not empty,
       // then take the first index not occupied
       int lastPosition = 0;
       if (!points->empty())
       {
         mitk::PointSet::PointsIterator it, end;
         it = points->Begin();
         end = points->End();
         while( it != end )
         {
           if (!points->IndexExists(lastPosition))
             break;
           ++it;
           ++lastPosition;
         }
       }
 
       PointOperation* doOp = new mitk::PointOperation(
         OpINSERT, timeInMS, itkPoint, lastPosition);
 
       if (m_UndoEnabled)
       {
         // difference between OpDELETE and OpREMOVE is, that OpDELETE deletes
         // a point at the end, and OpREMOVE deletes it from the given position
         // remove is better, cause we need the position to add or remove the
         // point anyway. We can get the last position from size()
         PointOperation *undoOp = new mitk::PointOperation(
           OpREMOVE, timeInMS, itkPoint, lastPosition);
         OperationEvent *operationEvent =
           new OperationEvent(pointSet, doOp, undoOp, "Add point");
         m_UndoController->SetOperationEvent(operationEvent);
       }
 
       //execute the Operation
       pointSet->ExecuteOperation(doOp);
 
       if ( !m_UndoEnabled )
         delete doOp;
 
       //the point is added and directly selected in PintSet. So no need to call OpSELECTPOINT
 
       ok = true;
 
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
   case AcINITMOVEMENT:
     {
       mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
 
       if (posEvent == NULL)
         return false;
 
       // start of the Movement is stored to calculate the undoKoordinate
       // in FinishMovement
       m_LastPoint = posEvent->GetWorldPosition();
 
       // initialize a value to calculate the movement through all
       // MouseMoveEvents from MouseClick to MouseRelease
       m_SumVec.Fill(0);
 
       ok = true;
       break;
     }
   case AcMOVESELECTED://moves all selected Elements
     {
       mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
 
       if (posEvent == NULL)
         return false;
 
       mitk::Point3D newPoint, resultPoint;
       newPoint = posEvent->GetWorldPosition();
       // search the elements in the list that are selected then calculate the
       // vector, because only with the vector we can move several elements in
       // the same direction
       //   newPoint - lastPoint = vector
       // then move all selected and set the lastPoint = newPoint.
       // then add all vectors to a summeryVector (to be able to calculate the
       // startpoint for undoOperation)
       mitk::Vector3D dirVector = newPoint - m_LastPoint;
 
       //sum up all Movement for Undo in FinishMovement
       m_SumVec = m_SumVec + dirVector;
 
       mitk::PointSet::PointsIterator it, end;
       it = points->Begin();
       end = points->End();
       while( it != end )
       {
         int position = it->Index();
         if ( pointSet->GetSelectInfo(position, m_TimeStep) )//if selected
         {
           PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
           mitk::Point3D sumVec;
           sumVec[0] = pt[0];
           sumVec[1] = pt[1];
           sumVec[2] = pt[2];
           resultPoint = sumVec + dirVector;
           PointOperation doOp(OpMOVE, timeInMS, resultPoint, position);
 
           //execute the Operation
           //here no undo is stored, because the movement-steps aren't interesting.
           // only the start and the end is interisting to store for undo.
           pointSet->ExecuteOperation(&doOp);
         }
         ++it;
       }
       m_LastPoint = newPoint;//for calculation of the direction vector
       ok = true;
 
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
 
   case AcREMOVEPOINT://remove the given Point from the list
     {
       //if the point to be removed is given by the positionEvent:
       mitk::PositionEvent const  *posEvent =
         dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
       if (posEvent != NULL)
       {
         mitk::Point3D itkPoint;
         itkPoint = posEvent->GetWorldPosition();
 
         //search the point in the list
         int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
         //distance set to 0, cause we already got the exact point from last
         //State checkpointbut we also need the position in the list to remove it
         if (position>=0)//found a point
         {
           PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
           itkPoint[0] = pt[0];
           itkPoint[1] = pt[1];
           itkPoint[2] = pt[2];
 
           //Undo
           PointOperation* doOp = new mitk::PointOperation(OpREMOVE,
             timeInMS, itkPoint, position);
           if (m_UndoEnabled)  //write to UndoMechanism
           {
             PointOperation* undoOp = new mitk::PointOperation(OpINSERT,
               timeInMS, itkPoint, position);
             OperationEvent *operationEvent = new OperationEvent(pointSet,
               doOp, undoOp, "Remove point");
             m_UndoController->SetOperationEvent(operationEvent);
           }
           //execute the Operation
           pointSet->ExecuteOperation(doOp);
 
           if ( !m_UndoEnabled )
             delete doOp;
 
           /*now select the point "position-1",
           and if it is the first in list,
           then contine at the last in list*/
 
 
           //only then a select of a point is possible!
           if (pointSet->GetSize( m_TimeStep ) > 0)
           {
             if (position>0)//not the first in list
             {
               this->SelectPoint( position-1, m_TimeStep, timeInMS );
             }
             //it was the first point in list, that was removed, so select
             //the last in list
             else
             {
               position = pointSet->GetSize( m_TimeStep ) - 1; //last in list
               this->SelectPoint( position, m_TimeStep, timeInMS );
             }//else
           }//if
 
           ok = true;
         }
       }
       else //no position is given so remove all selected elements
       {
         //delete all selected points
         //search for the selected one and then declare the operations!
         mitk::PointSet::PointsContainer::Iterator it, end;
         it = points->Begin();
         end = points->End();
         int position = 0;
         int previousExistingPosition = -1;//to recognize the last existing position; needed because the iterator gets invalid if the point is deleted!
         int lastDelPrevExistPosition = -1; //the previous position of the last deleted point
         while (it != end)
         {
           if (points->IndexExists(it->Index()))
           {
             //if point is selected
             if (  pointSet->GetSelectInfo(it->Index(), m_TimeStep) )
             {
               //get the coordinates of that point to be undoable
               PointSet::PointType selectedPoint = it->Value();
               mitk::Point3D itkPoint;
               itkPoint[0] = selectedPoint[0];
               itkPoint[1] = selectedPoint[1];
               itkPoint[2] = selectedPoint[2];
 
               position = it->Index();
               PointOperation* doOp = new mitk::PointOperation(OpREMOVE,
                 timeInMS, itkPoint, position);
               //Undo
               if (m_UndoEnabled)  //write to UndoMechanism
               {
                 PointOperation* undoOp = new mitk::PointOperation(OpINSERT,
                   timeInMS, itkPoint, position);
                 OperationEvent *operationEvent = new OperationEvent(pointSet,
                   doOp, undoOp, "Remove point");
                 m_UndoController->SetOperationEvent(operationEvent);
               }
               pointSet->ExecuteOperation(doOp);
 
               if ( !m_UndoEnabled )
                 delete doOp;
 
               //after delete the iterator is undefined, so start again
               //count to the last existing entry
               if (points->Size()>1 && points->IndexExists(previousExistingPosition))
               {
                 for (it = points->Begin(); it != points->End(); it++)
                 {
                   if (it->Index() == (unsigned int) previousExistingPosition)
                   {
                     lastDelPrevExistPosition = previousExistingPosition;
                     break; //return if the iterator on the last existing position is found
                   }
                 }
               }
               else // size <= 1 or no previous existing position set
               {
                 //search for the first existing position
                 for (it = points->Begin(); it != points->End(); it++)
                   if (points->IndexExists(it->Index()))
                   {
                     previousExistingPosition = it->Index();
                     break;
                   }
               }
 
               //now that we have set the iterator, lets get sure, that the next it++ will not crash!
               if (it == end) { break; }
 
             }//if
             else
             {
               previousExistingPosition = it->Index();
             }
           }//if index exists
 
           it++;
         }//while
 
         if (lastDelPrevExistPosition < 0)//the var has not been set because the first element was deleted and there was no prev position
           lastDelPrevExistPosition = previousExistingPosition; //go to the end
 
         /*
         * now select the point before the point/points that was/were deleted
         */
         if (pointSet->GetSize( m_TimeStep ) > 0) //only then a select of a point is possible!
         {
           if (points->IndexExists(lastDelPrevExistPosition))
           {
             this->SelectPoint( lastDelPrevExistPosition, m_TimeStep, timeInMS );
           }
           else
           {
             //select the first existing element
             for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); it++)
               if (points->IndexExists(it->Index()))
               {
                 this->SelectPoint( it->Index(), m_TimeStep, timeInMS );
                 break;
               }
           }
         }//if
         ok = true;
       }//else
     }//case
 
     // Update the display
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     break;
 
   // Remove all Points that have been set at once.
   // TODO: Undo function not supported yet.
   case AcREMOVEALL:
     {
       if ( !points->empty() )
       {
         PointSet::PointType pt;
         mitk::PointSet::PointsContainer::Iterator it, end;
         it = points->Begin();
         end = points->End();
         int position = 0;
         while ( it != end )
         {
           position = it->Index();
           if ( points->IndexExists( position ) )
           {
             pt = pointSet->GetPoint( position, m_TimeStep );
             PointOperation doOp( OpREMOVE, timeInMS, pt, position );
             ++it;
             pointSet->ExecuteOperation( &doOp );
           }
           else it++;
         }
       }
       ok = true;
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
 
   //Checking if the Point transmitted is close enough to one point. Then
   //generate a new event with the point and let this statemaschine
   //handle the event.
   case AcCHECKELEMENT:
     {
       mitk::PositionEvent const  *posEvent =
         dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
       if (posEvent != NULL)
       {
         mitk::Point3D worldPoint = posEvent->GetWorldPosition();
 
         int position = pointSet->SearchPoint( worldPoint, m_Precision, m_TimeStep );
         if (position>=0)//found a point near enough to the given point
         {
           //get that point, the one meant by the user!
           PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
           mitk::Point2D displPoint;
           displPoint[0] = worldPoint[0]; displPoint[1] = worldPoint[1];
           //new Event with information YES and with the correct point
           mitk::PositionEvent newPosEvent(posEvent->GetSender(), Type_None,
             BS_NoButton, BS_NoButton, Key_none, displPoint, pt);
           mitk::StateEvent newStateEvent(EIDYES, &newPosEvent);
           //call HandleEvent to leave the guard-state
           this->HandleEvent( &newStateEvent );
           ok = true;
         }
         else
         {
           //new Event with information NO
           mitk::StateEvent newStateEvent(EIDNO, posEvent);
           this->HandleEvent(&newStateEvent );
           ok = true;
         }
       }
       else
       {
         MITK_DEBUG("OperationError")<<this->GetType()<<" AcCHECKELEMENT expected PointOperation.";
 
         mitk::DisplayPositionEvent const  *disPosEvent =
           dynamic_cast <const mitk::DisplayPositionEvent *> (
             stateEvent->GetEvent());
         if (disPosEvent != NULL)
         { //2d Koordinates for 3D Interaction; return false to redo
           //the last statechange
           mitk::StateEvent newStateEvent(EIDNO, disPosEvent);
           this->HandleEvent(&newStateEvent);
           ok = true;
         }
       }
 
       break;
     }
   case AcCHECKONESELECTED:
     //check if there is a point that is selected
     {
       if (pointSet->GetNumberOfSelected(m_TimeStep)>0)
       {
         mitk::StateEvent newStateEvent( EIDYES, theEvent);
         this->HandleEvent( &newStateEvent );
       }
       else //not selected then call event EIDNO
       {
         //new Event with information NO
         mitk::StateEvent newStateEvent( EIDNO, theEvent);
         this->HandleEvent( &newStateEvent );
       }
       ok = true;
       break;
     }
   case AcCHECKSELECTED:
     /*check, if the given point is selected:
     if no, then send EIDNO
     if yes, then send EIDYES*/
 
     // check, if: because of the need to look up the point again, it is
     // possible, that we grab the wrong point in case there are two same points
     // so maybe we do have to set a global index for further computation,
     // as long, as the mouse is moved...
     {
       int position = -1;
       mitk::PositionEvent const  *posEvent =
         dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
       if (posEvent == NULL)
         return false;
       mitk::Point3D worldPoint = posEvent->GetWorldPosition();
 
       position = pointSet->SearchPoint(worldPoint, m_Precision, m_TimeStep);
 
       if (position>=0)
       {
         mitk::PositionEvent const  *newPosEvent =
           new mitk::PositionEvent(posEvent->GetSender(),
           posEvent->GetType(), posEvent->GetButton(),
           posEvent->GetButtonState(), posEvent->GetKey(),
           posEvent->GetDisplayPosition(), posEvent->GetWorldPosition());
 
         //if selected on true, then call Event EIDYES
         if (pointSet->GetSelectInfo(position, m_TimeStep))
         {
           mitk::StateEvent newStateEvent( EIDYES, newPosEvent );
           this->HandleEvent( &newStateEvent );
           ok = true;
 
           //saving the spot for calculating the direction vector in moving
           m_LastPoint = posEvent->GetWorldPosition();
         }
         else //not selected then call event EIDNO
         {
           //new Event with information NO
           mitk::StateEvent newStateEvent( EIDNO, newPosEvent );
           this->HandleEvent( &newStateEvent );
           ok = true;
         }
         delete newPosEvent;
       }
       //the position wasn't set properly. If necessary: search the given
       //point in list and set var position
       else
       {
         /*
          mitk::StatusBar::GetInstance()->DisplayText(
           "Message from mitkPointSetInteractor: Error in Actions! Check Config XML-file",
           10000);
         */
         ok = false;
       }
 
       break;
     }
 
   //generate Events if the set will be full after the addition of the
   // point or not.
   case AcCHECKNMINUS1:
     {
       // number of points not limited->pass on
       // "Amount of points in Set is smaller then N-1"
       if (m_N<0)
       {
         mitk::StateEvent newStateEvent(EIDSTSMALERNMINUS1, stateEvent->GetEvent());
         this->HandleEvent( &newStateEvent );
         ok = true;
       }
       else
       {
         if (pointSet->GetSize( m_TimeStep ) < m_N-1 )
           //pointset after addition won't be full
         {
           mitk::StateEvent newStateEvent(EIDSTSMALERNMINUS1, stateEvent->GetEvent());
           this->HandleEvent( &newStateEvent );
           ok = true;
         }
         else
           //after the addition of a point, the container will be full
         {
           mitk::StateEvent newStateEvent(EIDSTLARGERNMINUS1, stateEvent->GetEvent());
           this->HandleEvent( &newStateEvent );
           ok = true;
         }//else
       }//else
     }
     break;
   case AcCHECKEQUALS1:
     {
       //the number of points in the list is 1 (or smaler)
       if (pointSet->GetSize( m_TimeStep ) <= 1)
       {
         mitk::StateEvent newStateEvent(EIDYES, stateEvent->GetEvent());
         this->HandleEvent( &newStateEvent );
         ok = true;
       }
       else //more than 1 points in list, so stay in the state!
       {
         mitk::StateEvent newStateEvent(EIDNO, stateEvent->GetEvent());
         this->HandleEvent( &newStateEvent );
         ok = true;
       }
     }
     break;
   case AcCHECKNUMBEROFPOINTS:
     {
       //the number of points in the list is 1 (or smaler), so will be empty after delete
      if (pointSet->GetSize( m_TimeStep ) <= 1)
       {
         mitk::StateEvent newStateEvent(EIDEMPTY, stateEvent->GetEvent());
         this->HandleEvent( &newStateEvent );
         ok = true;
       }
       else if (pointSet->GetSize( m_TimeStep ) <= m_N || m_N <= -1)
        //m_N is set to unlimited points allowed or more than 1 points in list, but not full, so stay in the state!
      {
        // if the number of points equals m_N and no point of the point set is selected switch to state EIDEQUALSN
        if ((pointSet->GetSize( m_TimeStep ) == m_N)&&(pointSet->GetNumberOfSelected()==0))
        {
          mitk::StateEvent newStateEvent(EIDEQUALSN, stateEvent->GetEvent());
          this->HandleEvent( &newStateEvent );
          ok = true;
        }
        // if the number of points is small than or equal m_N and point(s) are selected stay in state
        else
        {
          mitk::StateEvent newStateEvent(EIDSMALLERN, stateEvent->GetEvent());
          this->HandleEvent( &newStateEvent );
          ok = true;
        }
      }
       else
         //pointSet->GetSize( m_TimeStep ) >=m_N.
         // This can happen if the points were not added
         // by interaction but by loading a .mps file
       {
         mitk::StateEvent newStateEvent(EIDEQUALSN, stateEvent->GetEvent());
         this->HandleEvent( &newStateEvent );
         ok = true;
       }
     }
     break;
   case AcSELECTPICKEDOBJECT://and deselect others
     {
       mitk::PositionEvent const  *posEvent =
         dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
       if (posEvent == NULL) return false;
 
       mitk::Point3D itkPoint;
       itkPoint = posEvent->GetWorldPosition();
 
       //search the point in the list
       int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
       //distance set to 0, cause we already got the exact point from last
       //State checkpoint but we also need the position in the list to move it
       if (position>=0)//found a point
       {
         //first deselect the other points
         //undoable deselect of all points in the DataList
         this->UnselectAll( m_TimeStep, timeInMS);
 
         PointOperation* doOp = new mitk::PointOperation(OpSELECTPOINT,
           timeInMS, itkPoint, position);
 
         //Undo
         if (m_UndoEnabled)  //write to UndoMechanism
         {
           PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT,
             timeInMS, itkPoint, position);
           OperationEvent *operationEvent =
             new OperationEvent(pointSet, doOp, undoOp);
           m_UndoController->SetOperationEvent(operationEvent);
         }
 
         //execute the Operation
         pointSet->ExecuteOperation(doOp);
 
         if ( !m_UndoEnabled )
           delete doOp;
 
         ok = true;
       }
 
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
 
   case AcDESELECTOBJECT:
     {
       mitk::PositionEvent const  *posEvent =
         dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
       if (posEvent == NULL)
         return false;
 
       mitk::Point3D itkPoint;
       itkPoint = posEvent->GetWorldPosition();
 
       //search the point in the list
       int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
 
       //distance set to 0, cause we already got the exact point from last
       // State checkpoint but we also need the position in the list to move it
       if (position>=0)//found a point
       {
         //Undo
         PointOperation* doOp = new mitk::PointOperation(OpDESELECTPOINT,
           timeInMS, itkPoint, position);
         if (m_UndoEnabled)  //write to UndoMechanism
         {
           PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT,
             timeInMS, itkPoint, position);
           OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
           m_UndoController->SetOperationEvent(operationEvent);
         }
         //execute the Operation
         pointSet->ExecuteOperation(doOp);
 
         if ( !m_UndoEnabled )
           delete doOp;
 
         ok = true;
       }
 
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
 
   case AcDESELECTALL:
     {
       //undo-supported able deselect of all points in the DataList
       this->UnselectAll( m_TimeStep, timeInMS );
       ok = true;
 
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
 
   case AcFINISHMOVEMENT:
     {
       mitk::PositionEvent const *posEvent =
         dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
       if (posEvent == NULL)
         return false;
 
       //finish the movement:
       //the final point is m_LastPoint
       //m_SumVec stores the movement in a vector
       //the operation would not be necessary, but we need it for the undo Operation.
       //m_LastPoint is for the Operation
       //the point for undoOperation calculates from all selected
       //elements (point) - m_SumVec
 
       //search all selected elements and move them with undo-functionality.
       mitk::PointSet::PointsIterator it, end;
       it = points->Begin();
       end = points->End();
       while( it != end )
       {
         int position = it->Index();
         if ( pointSet->GetSelectInfo(position, m_TimeStep) )//if selected
         {
           PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
           Point3D itkPoint;
           itkPoint[0] = pt[0];
           itkPoint[1] = pt[1];
           itkPoint[2] = pt[2];
           PointOperation* doOp = new mitk::PointOperation(OpMOVE,
             timeInMS, itkPoint, position);
 
           if ( m_UndoEnabled )//&& (posEvent->GetType() == mitk::Type_MouseButtonRelease)
           {
             //set the undo-operation, so the final position is undo-able
             //calculate the old Position from the already moved position - m_SumVec
             mitk::Point3D undoPoint = ( itkPoint - m_SumVec );
             PointOperation* undoOp =
               new mitk::PointOperation(OpMOVE, timeInMS, undoPoint, position);
             OperationEvent *operationEvent =
               new OperationEvent(pointSet, doOp, undoOp, "Move point");
             m_UndoController->SetOperationEvent(operationEvent);
           }
           //execute the Operation
           pointSet->ExecuteOperation(doOp);
 
           if ( !m_UndoEnabled )
             delete doOp;
 
         }
         ++it;
       }
 
       //set every variable for movement calculation to zero
       // commented out: increases usebility in derived classes.
       /*m_LastPoint.Fill(0);
       m_SumVec.Fill(0);*/
 
       //increase the GroupEventId, so that the Undo goes to here
       this->IncCurrGroupEventId();
       ok = true;
 
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
 
   case AcCLEAR:
     {
       this->Clear( m_TimeStep, timeInMS );
 
       // Update the display
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
 
   default:
     return Superclass::ExecuteAction( action, stateEvent );
   }
   // indicate modification of data tree node
   m_DataNode->Modified();
   return ok;
 }
 
 void mitk::PointSetInteractor::Clear( unsigned int timeStep, ScalarType timeInMS )
 {
   mitk::Point3D point;
   point.Fill(0);
 
   mitk::PointSet *pointSet =
     dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
   if ( pointSet == NULL )
   {
     return;
   }
 
   mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet( timeStep );
   if ( itkPointSet == NULL )
   {
     return;
   }
 
   //for reading on the points, Id's etc
   mitk::PointSet::PointsContainer *points = itkPointSet->GetPoints();
 
   mitk::PointSet::PointsIterator it, end;
   it = points->Begin();
   end = points->End();
   while( (it != end) && (pointSet->GetSize( timeStep ) > 0) )
   {
     point = pointSet->GetPoint( it->Index(), timeStep );
     PointOperation *doOp = new mitk::PointOperation(
       OpREMOVE, timeInMS, point, it->Index());
 
     //write to UndoMechanism
     if ( m_UndoEnabled )
     {
       PointOperation *undoOp = new mitk::PointOperation(
         OpINSERT, timeInMS, point, it->Index());
 
       OperationEvent *operationEvent =
         new OperationEvent( pointSet, doOp, undoOp );
 
       m_UndoController->SetOperationEvent( operationEvent );
     }
     //execute the Operation
 
     ++it;
     pointSet->ExecuteOperation( doOp );
 
     if ( !m_UndoEnabled )
       delete doOp;
 
   }
 
   //reset the statemachine
   this->ResetStatemachineToStartState(timeStep);
 }
 
 
 void mitk::PointSetInteractor::InitAccordingToNumberOfPoints()
 {
   if (m_DataNode == NULL)
     return;
 
   mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
   if ( pointSet != NULL )
   {
     //resize the CurrentStateVector
     this->ExpandStartStateVector(pointSet->GetPointSetSeriesSize());
 
     for (unsigned int timestep = 0; timestep < pointSet->GetPointSetSeriesSize(); timestep++)
     {
       //go to new timestep
       this->UpdateTimeStep(timestep);
 
       int numberOfPoints = pointSet->GetSize( timestep );
       if (numberOfPoints == 0)
         continue; //pointset is empty
       else
       {
         //we have a set of loaded points. Deselect all points, because they are all set to selected when added!
         this->UnselectAll(timestep);
 
         if (numberOfPoints<m_N || m_N <= -1)//if less than specified or specified as unlimited
         {
           //get the currentState to state "SpaceLeft"
           const mitk::Event nullEvent(NULL, Type_User, BS_NoButton, BS_NoButton, Key_none);
           mitk::StateEvent newStateEvent(EIDSMALLERN, &nullEvent);
           this->HandleEvent( &newStateEvent );
         }
         else if (numberOfPoints>=m_N)
         {
           if (numberOfPoints>m_N)
           {
             STATEMACHINE_WARN<<"Point Set contains more points than needed!\n";//display a warning that there are too many points
           }
           //get the currentState to state "Set full"
           const mitk::Event nullEvent(NULL, Type_User, BS_NoButton, BS_NoButton, Key_none);
           mitk::StateEvent newStateEvent(EIDEQUALSN, &nullEvent);
           this->HandleEvent( &newStateEvent );
         }
       }
     }
   }
   return;
 }
 
 void mitk::PointSetInteractor::DataChanged()
 {
   this->InitAccordingToNumberOfPoints();
   return;
 }
diff --git a/Core/Code/Rendering/mitkBaseRenderer.cpp b/Core/Code/Rendering/mitkBaseRenderer.cpp
index fb1fef1657..81e1445a12 100644
--- a/Core/Code/Rendering/mitkBaseRenderer.cpp
+++ b/Core/Code/Rendering/mitkBaseRenderer.cpp
@@ -1,880 +1,892 @@
 /*===================================================================
 
  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) :
     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_TimeSlicedWorldGeometry(NULL), m_CurrentWorldGeometry(NULL), m_CurrentWorldGeometry2D(NULL), m_DisplayGeometry(
+    m_Focused(false), m_WorldGeometry(NULL), m_TimeWorldGeometry(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(
         true), m_DepthPeelingEnabled(true), m_MaxNumberOfPeels(100), 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_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_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
   m_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
 
   m_CurrentWorldGeometry2DTransformTime = m_CurrentWorldGeometry2DNode->GetVtkTransform()->GetMTime();
 
   m_DisplayGeometry = mitk::DisplayGeometry::New();
   m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
   m_DisplayGeometryData = mitk::Geometry2DData::New();
   m_DisplayGeometryData->SetGeometry2D(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 (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_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;
   }
 
   if (m_OverlayManager.IsNotNull())
   {
     m_OverlayManager->RemoveBaseRenderer(this);
   }
 }
 
 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(Point2D* mousePosition) const
 {
   Point2D p_mm;
   Point3D position;
   if (m_MapperID == 1)
   {
     GetDisplayGeometry()->ULDisplayToDisplay(*mousePosition, *mousePosition);
     GetDisplayGeometry()->DisplayToWorld(*mousePosition, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
   }
   else if (m_MapperID == 2)
   {
     GetDisplayGeometry()->ULDisplayToDisplay(*mousePosition, *mousePosition);
     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);
   }
 
   //BUG (#1551) added settings for depth peeling
   m_RenderWindow->SetAlphaBitPlanes(1);
   m_VtkRenderer->SetUseDepthPeeling(m_DepthPeelingEnabled);
   m_VtkRenderer->SetMaximumNumberOfPeels(m_MaxNumberOfPeels);
   m_VtkRenderer->SetOcclusionRatio(0.1);
 }
 
 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_TimeSlicedWorldGeometry.IsNotNull())
+    if (m_TimeWorldGeometry.IsNotNull())
     {
-      SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_TimeSlicedWorldGeometry->GetGeometry3D(m_TimeStep));
+      SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_TimeWorldGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
         if (m_Slice >= slicedWorldGeometry->GetSlices())
           m_Slice = slicedWorldGeometry->GetSlices() - 1;
         SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(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_TimeSlicedWorldGeometry.IsNotNull())
+    if (m_TimeWorldGeometry.IsNotNull())
     {
-      if (m_TimeStep >= m_TimeSlicedWorldGeometry->GetTimeSteps())
-        m_TimeStep = m_TimeSlicedWorldGeometry->GetTimeSteps() - 1;
-      SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_TimeSlicedWorldGeometry->GetGeometry3D(m_TimeStep));
+      if (m_TimeStep >= m_TimeWorldGeometry->GetNumberOfTimeSteps())
+        m_TimeStep = m_TimeWorldGeometry->GetNumberOfTimeSteps() - 1;
+      SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_TimeWorldGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
         SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(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->GetTimeSlicedGeometry()->MSToTimeStep(GetTime());
+  return data->GetTimeGeometry()->TimePointToTimeStep(GetTime());
 }
 
 mitk::ScalarType mitk::BaseRenderer::GetTime() const
 {
-  if (m_TimeSlicedWorldGeometry.IsNull())
+  if (m_TimeWorldGeometry.IsNull())
   {
     return 0;
   }
   else
   {
-    ScalarType timeInMS = m_TimeSlicedWorldGeometry->TimeStepToMS(GetTimeStep());
+    ScalarType timeInMS = m_TimeWorldGeometry->TimeStepToTimePoint(GetTimeStep());
     if (timeInMS == ScalarTypeNumericTraits::NonpositiveMin())
       return 0;
     else
       return timeInMS;
   }
 }
 
-void mitk::BaseRenderer::SetWorldGeometry(mitk::Geometry3D* geometry)
+void mitk::BaseRenderer::SetWorldTimeGeometry(mitk::TimeGeometry* geometry)
 {
-  itkDebugMacro("setting WorldGeometry to " << geometry);
+  assert(geometry != NULL);
+
+  itkDebugMacro("setting WorldTimeGeometry to " << geometry);
+  if (m_TimeWorldGeometry != geometry)
+  {
+    if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() == 0)
+      return;
+
+    m_TimeWorldGeometry = geometry;
+    itkDebugMacro("setting TimeWorldGeometry to " << m_TimeWorldGeometry);
+
+    if (m_TimeStep >= m_TimeWorldGeometry->GetNumberOfTimeSteps())
+        m_TimeStep = m_TimeWorldGeometry->GetNumberOfTimeSteps() - 1;
+
+    Geometry3D* geometry3d;
+    geometry3d = m_TimeWorldGeometry->GetGeometryForTimeStep(m_TimeStep);
+    SetWorldGeometry3D(geometry3d);
+  }
+}
+
+void mitk::BaseRenderer::SetWorldGeometry3D(mitk::Geometry3D* geometry)
+{
+  itkDebugMacro("setting WorldGeometry3D to " << geometry);
 
   if (m_WorldGeometry != geometry)
   {
     if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldGeometry = geometry;
-    m_TimeSlicedWorldGeometry = dynamic_cast<TimeSlicedGeometry*>(geometry);
     SlicedGeometry3D* slicedWorldGeometry;
-    if (m_TimeSlicedWorldGeometry.IsNotNull())
-    {
-      itkDebugMacro("setting TimeSlicedWorldGeometry to " << m_TimeSlicedWorldGeometry);
-      if (m_TimeStep >= m_TimeSlicedWorldGeometry->GetTimeSteps())
-        m_TimeStep = m_TimeSlicedWorldGeometry->GetTimeSteps() - 1;
-      slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_TimeSlicedWorldGeometry->GetGeometry3D(m_TimeStep));
-    }
-    else
-    {
-      slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(geometry);
-    }
+    slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(geometry);
+
     Geometry2D::Pointer geometry2d;
     if (slicedWorldGeometry != NULL)
     {
       if (m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
         m_Slice = slicedWorldGeometry->GetSlices() - 1;
       geometry2d = slicedWorldGeometry->GetGeometry2D(m_Slice);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
         plane->InitializeStandardPlane(slicedWorldGeometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(slicedWorldGeometry);
     }
     else
     {
       geometry2d = dynamic_cast<Geometry2D*>(geometry);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = PlaneGeometry::New();
         plane->InitializeStandardPlane(geometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(geometry);
     }
     SetCurrentWorldGeometry2D(geometry2d); // calls Modified()
   }
   if (m_CurrentWorldGeometry2D.IsNull())
     itkWarningMacro("m_CurrentWorldGeometry2D 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_DisplayGeometryUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SetCurrentWorldGeometry2D(mitk::Geometry2D* geometry2d)
 {
   if (m_CurrentWorldGeometry2D != geometry2d)
   {
     m_CurrentWorldGeometry2D = geometry2d;
     m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
     m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
     m_CurrentWorldGeometry2DUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SendUpdateSlice()
 {
   m_DisplayGeometryUpdateTime.Modified();
   m_CurrentWorldGeometry2DUpdateTime.Modified();
 }
 
 void mitk::BaseRenderer::SetCurrentWorldGeometry(mitk::Geometry3D* 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);
-  SetWorldGeometry(sendEvent->GetTimeSlicedGeometry());
+  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)
     {
       Geometry2D* geometry2D = slicedWorldGeometry->GetGeometry2D(m_Slice);
 
       SetCurrentWorldGeometry2D(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->SetInputWorldGeometry(SlicenavigationController->GetCreatedWorldGeometry());
+  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 << "NULL" << std::endl;
   else
     m_CurrentWorldGeometry2D->Print(os, indent);
 
   os << indent << " CurrentWorldGeometry2DUpdateTime: " << m_CurrentWorldGeometry2DUpdateTime << std::endl;
   os << indent << " CurrentWorldGeometry2DTransformTime: " << m_CurrentWorldGeometry2DTransformTime << 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);
 }
 
 void mitk::BaseRenderer::SetDepthPeelingEnabled(bool enabled)
 {
   m_DepthPeelingEnabled = enabled;
   m_VtkRenderer->SetUseDepthPeeling(enabled);
 }
 
 void mitk::BaseRenderer::SetMaxNumberOfPeels(int maxNumber)
 {
   m_MaxNumberOfPeels = maxNumber;
   m_VtkRenderer->SetMaximumNumberOfPeels(maxNumber);
 }
 
diff --git a/Core/Code/Rendering/mitkBaseRenderer.h b/Core/Code/Rendering/mitkBaseRenderer.h
index 6c4ab6b16e..149a65dc6f 100644
--- a/Core/Code/Rendering/mitkBaseRenderer.h
+++ b/Core/Code/Rendering/mitkBaseRenderer.h
@@ -1,630 +1,642 @@
 /*===================================================================
 
  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 "mitkGeometry2D.h"
-#include "mitkTimeSlicedGeometry.h"
+#include "mitkTimeGeometry.h"
 #include "mitkDisplayGeometry.h"
 #include "mitkGeometry2DData.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:
     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);
 
     //##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 Geometry2D (which is a sub-class of Geometry3D), m_CurrentWorldGeometry2D is
-    //## also set to point to it. m_TimeSlicedWorldGeometry is set to NULL.
-    //## \li if it is a TimeSlicedGeometry, m_TimeSlicedWorldGeometry is also set to point to it.
-    //## If m_TimeSlicedWorldGeometry contains instances of SlicedGeometry3D, m_CurrentWorldGeometry2D is set to
+    //## also set to point to it. m_TimeWorldGeometry is set to NULL.
+    //## \li if it is a TimeGeometry, m_TimeWorldGeometry is also set to point to it.
+    //## If m_TimeWorldGeometry contains instances of SlicedGeometry3D, m_CurrentWorldGeometry2D 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_TimeSlicedWorldGeometry is set to NULL.
+    //## is set as the m_CurrentWorldGeometry2D. m_TimeWorldGeometry 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.
     //## \sa m_WorldGeometry
-    //## \sa m_TimeSlicedWorldGeometry
+    //## \sa m_TimeWorldGeometry
     //## \sa m_CurrentWorldGeometry2D
-    virtual void SetWorldGeometry(Geometry3D* geometry);
+    virtual void SetWorldGeometry3D(Geometry3D* geometry);
+    virtual void SetWorldTimeGeometry(mitk::TimeGeometry* geometry);
+
+
+    /**
+    * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
+    */
+    DEPRECATED(void SetWorldGeometry3D(TimeSlicedGeometry* geometry));
+
 
-    itkGetConstObjectMacro(WorldGeometry, Geometry3D)
+    itkGetConstObjectMacro(WorldGeometry, Geometry3D);
+    itkGetConstObjectMacro(TimeWorldGeometry, TimeGeometry);
 
     //##Documentation
     //## @brief Get the current 3D-worldgeometry (m_CurrentWorldGeometry) used for 3D-rendering
     itkGetConstObjectMacro(CurrentWorldGeometry, Geometry3D)
 
     //##Documentation
     //## @brief Get the current 2D-worldgeometry (m_CurrentWorldGeometry2D) used for 2D-rendering
     itkGetConstObjectMacro(CurrentWorldGeometry2D, Geometry2D)
 
     //##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 Geometry2D m_CurrentWorldGeometry2D
     //## 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_TimeSlicedWorldGeometry used as m_CurrentWorldGeometry2D
+    //## stored in m_TimeWorldGeometry used as m_CurrentWorldGeometry2D
     //##
     //## \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_TimeSlicedWorldGeometry used as m_CurrentWorldGeometry2D
+    //## stored in m_TimeWorldGeometry used as m_CurrentWorldGeometry2D
     //##
     //## \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)
     //##Documentation
     //## @brief Get a data object containing the WorldGeometry (for 2D rendering)
     itkGetObjectMacro(WorldGeometryData, Geometry2DData)
 
     //##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)
 
     //##Documentation
     //## @brief Sets timestamp of CurrentWorldGeometry2D and DisplayGeometry and forces so reslicing in that renderwindow
     void SendUpdateSlice();
 
     //##Documentation
     //## @brief Get timestamp of last call of SetCurrentWorldGeometry2D
     unsigned long GetCurrentWorldGeometry2DUpdateTime()
     {
       return m_CurrentWorldGeometry2DUpdateTime;
     }
     //##Documentation
     //## @brief Get timestamp of last call of SetDisplayGeometry
     unsigned long GetDisplayGeometryUpdateTime()
     {
       return m_CurrentWorldGeometry2DUpdateTime;
     }
     //##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)
 
     //##Documentation
     //## @brief Sets whether depth peeling is enabled or not
     void SetDepthPeelingEnabled(bool enabled);  //##Documentation
     //## @brief Sets maximal number of peels
     void SetMaxNumberOfPeels(int maxNumber);
 
     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(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(Geometry2D* geometry2d);
 
     //##Documentation
     //## @brief Sets m_CurrentWorldGeometry
     virtual void SetCurrentWorldGeometry(Geometry3D* 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
     Geometry3D::Pointer m_WorldGeometry;
 
     itk::SmartPointer<OverlayManager> m_OverlayManager;
 
     //##Documentation
-    //## m_TimeSlicedWorldGeometry is set by SetWorldGeometry if the passed Geometry3D is a
-    //## TimeSlicedGeometry (or a sub-class of it). If it contains instances of SlicedGeometry3D,
+    //## m_TimeWorldGeometry is set by SetWorldGeometry if the passed Geometry3D 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_TimeSlicedWorldGeometry (if available)
+    //## which 2D geometry stored in m_TimeWorldGeometry (if available)
     //## is used as m_CurrentWorldGeometry2D.
     //## \sa m_CurrentWorldGeometry2D
-    TimeSlicedGeometry::Pointer m_TimeSlicedWorldGeometry;
+    TimeGeometry::Pointer m_TimeWorldGeometry;
 
     //##Documentation
     //## Pointer to the current 3D-worldgeometry.
     Geometry3D::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).
     Geometry2D::Pointer m_CurrentWorldGeometry2D;
 
     //##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_TimeSlicedWorldGeometry
-    //## is used as m_CurrentWorldGeometry2D: m_TimeSlicedWorldGeometry->GetGeometry2D(m_Slice, m_TimeStep).
-    //## \sa m_TimeSlicedWorldGeometry
+    //## Defines together with m_Slice which 2D geometry stored in m_TimeWorldGeometry
+    //## is used as m_CurrentWorldGeometry2D: m_TimeWorldGeometry->GetGeometry2D(m_Slice, m_TimeStep).
+    //## \sa m_TimeWorldGeometry
     unsigned int m_Slice;
     //##Documentation
-    //## Defines together with m_TimeStep which 2D geometry stored in m_TimeSlicedWorldGeometry
-    //## is used as m_CurrentWorldGeometry2D: m_TimeSlicedWorldGeometry->GetGeometry2D(m_Slice, m_TimeStep).
-    //## \sa m_TimeSlicedWorldGeometry
+    //## Defines together with m_TimeStep which 2D geometry stored in m_TimeWorldGeometry
+    //## is used as m_CurrentWorldGeometry2D: m_TimeWorldGeometry->GetGeometry2D(m_Slice, m_TimeStep).
+    //## \sa m_TimeWorldGeometry
     unsigned int m_TimeStep;
 
     //##Documentation
     //## @brief timestamp of last call of SetWorldGeometry
     itk::TimeStamp m_CurrentWorldGeometry2DUpdateTime;
 
     //##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;
     //##Documentation
     //## Data object containing the m_DisplayGeometry defined above.
     Geometry2DData::Pointer m_DisplayGeometryData;
     //##Documentation
     //## Data object containing the m_CurrentWorldGeometry2D defined above.
     Geometry2DData::Pointer m_CurrentWorldGeometry2DData;
 
     //##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;
 
     //##Documentation
     //## @brief test only
     unsigned long m_DisplayGeometryTransformTime;
     //##Documentation
     //## @brief test only
     unsigned long m_CurrentWorldGeometry2DTransformTime;
 
     std::string m_Name;
 
     double m_Bounds[6];
 
     bool m_EmptyWorldGeometry;
 
     bool m_DepthPeelingEnabled;
 
     int m_MaxNumberOfPeels;
 
     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 */
diff --git a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
index 4d401f3466..73db2784a6 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
+++ b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
@@ -1,672 +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 "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkPlaneOrientationProperty.h"
 #include "mitkGeometry2DDataToSurfaceFilter.h"
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkLine.h"
 #include "mitkNodePredicateDataType.h"
 
 #include "mitkResliceMethodProperty.h"
 
 
 mitk::Geometry2DDataMapper2D::Geometry2DDataMapper2D()
 : m_SurfaceMapper( NULL ), m_DataStorage(NULL), m_ParentNode(NULL),
   m_OtherGeometry2Ds(), m_RenderOrientationArrows( false ),
   m_ArrowOrientationPositive( true )
 {
 }
 
 
 mitk::Geometry2DDataMapper2D::~Geometry2DDataMapper2D()
 {
 }
 
 
 const mitk::Geometry2DData* mitk::Geometry2DDataMapper2D::GetInput(void)
 {
   return static_cast<const Geometry2DData * > ( GetDataNode()->GetData() );
 }
 
 void mitk::Geometry2DDataMapper2D::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();
   if (m_DataStorage.IsNull())
     return;
 
   mitk::NodePredicateDataType::Pointer p = mitk::NodePredicateDataType::New("Geometry2DData");
   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);
     if(geometry2dData == NULL)
       continue;
 
     PlaneGeometry* planegeometry = dynamic_cast<PlaneGeometry*>(geometry2dData->GetGeometry2D());
     if (planegeometry != NULL)
       m_OtherGeometry2Ds.push_back(it->Value());
   }
 }
 
 
 void mitk::Geometry2DDataMapper2D::Paint(BaseRenderer *renderer)
 {
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if(!visible) return;
 
   Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());
 
   // intersecting with ourself?
   if ( input.IsNull() || (this->GetInput()->GetGeometry2D() ==
        renderer->GetCurrentWorldGeometry2D()) )
   {
     return; // do nothing!
   }
 
   const PlaneGeometry *inputPlaneGeometry =
     dynamic_cast< const PlaneGeometry * >( input->GetGeometry2D() );
 
   const PlaneGeometry *worldPlaneGeometry =
     dynamic_cast< const PlaneGeometry* >(
     renderer->GetCurrentWorldGeometry2D() );
 
   if ( worldPlaneGeometry && inputPlaneGeometry
     && inputPlaneGeometry->GetReferenceGeometry() )
   {
     DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
     assert( displayGeometry );
 
     const Geometry3D *referenceGeometry =
       inputPlaneGeometry->GetReferenceGeometry();
 
     // calculate intersection of the plane data with the border of the
     // world geometry rectangle
     Point2D lineFrom, lineTo;
 
-    typedef Geometry3D::TransformType TransformType;
-    const TransformType *transform = dynamic_cast< const TransformType * >(
+    const Geometry3D::TransformType *transform = dynamic_cast< const Geometry3D::TransformType * >(
       referenceGeometry->GetIndexToWorldTransform() );
 
-    TransformType::Pointer inverseTransform = TransformType::New();
+    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.push_back( 0.0 );
         mainLineParams.push_back( 1.0 );
 
         primaryHelperLineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
         primaryHelperLineParams.push_back( 0.0 );
         primaryHelperLineParams.push_back( 1.0 );
 
         secondaryHelperLineParams.reserve( m_OtherGeometry2Ds.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();
 
         //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() );
 
           // 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();
         while ( otherPlanesIt != otherPlanesEnd )
         {
           PlaneGeometry *otherPlane = static_cast< PlaneGeometry * >(
             static_cast< Geometry2DData * >(
               (*otherPlanesIt)->GetData() )->GetGeometry2D() );
 
 
           // 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;
     SmartPointerProperty::Pointer surfacecreatorprop;
     surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(
       GetDataNode()->GetProperty(
         "surfacegeometry", renderer));
 
     if( (surfacecreatorprop.IsNull()) ||
         (surfacecreatorprop->GetSmartPointer().IsNull()) ||
         ((surfaceCreator = dynamic_cast< Geometry2DDataToSurfaceFilter * >(
           surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull())
       )
     {
       surfaceCreator = Geometry2DDataToSurfaceFilter::New();
       surfacecreatorprop = SmartPointerProperty::New(surfaceCreator);
       surfaceCreator->PlaceByGeometryOn();
       GetDataNode()->SetProperty( "surfacegeometry", surfacecreatorprop );
     }
 
     surfaceCreator->SetInput( input );
 
     // Clip the Geometry2D with the reference geometry bounds (if available)
     if ( input->GetGeometry2D()->HasReferenceGeometry() )
     {
       surfaceCreator->SetBoundingBox(
         input->GetGeometry2D()->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 Geometry2D
     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,
   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 )
 {
   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 )
 {
   if (ds.IsNotNull())
   {
     m_DataStorage = ds;
   }
   if (parent.IsNotNull())
   {
     m_ParentNode = parent;
   }
 }
 
 void mitk::Geometry2DDataMapper2D::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() );
 
   // 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 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,
                                                                      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/mitkImageVtkMapper2D.cpp b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
index 59c8d52dc7..50c93ac0bd 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,1092 +1,1091 @@
 /*===================================================================
 
 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 <mitkTimeSlicedGeometry.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,
   //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, vtkFloatingPointType planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   //Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   //plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   //These two points define the axes of the plane in combination with the origin.
   //Point 1 is the x-axis and point 2 the y-axis.
   //Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1] , planeBounds[2], depth); //P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); //P2: (xMin, yMax, depth)
 }
 
 float mitk::ImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer* renderer)
 {
   //get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   //Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange*0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty( "layer", layer, renderer);
   //add the layer property for each image to render images with a higher layer on top of the others
   depth += layer*10; //*10: keep some room for each image (e.g. for QBalls in between)
   if(depth > 0.0f) {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 const mitk::Image* mitk::ImageVtkMapper2D::GetInput( void )
 {
   return static_cast< const mitk::Image * >( GetDataNode()->GetData() );
 }
 
 vtkProp* mitk::ImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actors;
 }
 
 
 
 void mitk::ImageVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
   mitk::DataNode* datanode = this->GetDataNode();
 
   if ( input == NULL || input->IsInitialized() == false )
   {
     return;
   }
 
   //check if there is a valid worldGeometry
   const Geometry2D *worldGeometry = renderer->GetCurrentWorldGeometry2D();
   if( ( worldGeometry == NULL ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))
   {
     return;
   }
 
   input->Update();
 
   // early out if there is no intersection of the current rendering geometry
   // and the geometry of the image that is to be rendered.
   if ( !RenderingGeometryIntersectsImage( worldGeometry, input->GetSlicedGeometry() ) )
   {
     // set image to NULL, to clear the texture in 3D, because
     // the latest image is used there if the plane is out of the geometry
     // see bug-13275
     localStorage->m_ReslicedImage = NULL;
     localStorage->m_Mapper->SetInput( 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->GetTimeSlicedGeometry()->GetGeometry3D( this->GetTimestep() ) );
+  localStorage->m_Reslicer->SetResliceTransformByGeometry( input->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() ) );
 
 
   //is the geometry of the slice based on the input image or the worldgeometry?
   bool inPlaneResampleExtentByGeometry = false;
   datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
   localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
 
 
   // Initialize the interpolation mode for resampling; switch to nearest
   // neighbor if the input image is too small.
   if ( (input->GetDimension() >= 3) && (input->GetDimension(2) > 1) )
   {
     VtkResliceInterpolationProperty *resliceInterpolationProperty;
     datanode->GetProperty(
           resliceInterpolationProperty, "reslice interpolation" );
 
     int interpolationMode = VTK_RESLICE_NEAREST;
     if ( resliceInterpolationProperty != NULL )
     {
       interpolationMode = resliceInterpolationProperty->GetInterpolation();
     }
 
     switch ( interpolationMode )
     {
     case VTK_RESLICE_NEAREST:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
       break;
     case VTK_RESLICE_LINEAR:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
       break;
     case VTK_RESLICE_CUBIC:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
       break;
     }
   }
   else
   {
     localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
   }
 
   //set the vtk output property to true, makes sure that no unneeded mitk image convertion
   //is done.
   localStorage->m_Reslicer->SetVtkOutputRequest(true);
 
 
   //Thickslicing
   int thickSlicesMode = 0;
   int thickSlicesNum = 1;
   // Thick slices parameters
   if( input->GetPixelType().GetNumberOfComponents() == 1 ) // for now only single component are allowed
   {
     DataNode *dn=renderer->GetCurrentWorldGeometry2DNode();
     if(dn)
     {
       ResliceMethodProperty *resliceMethodEnumProperty=0;
 
       if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )
         thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
 
       IntProperty *intProperty=0;
       if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty )
       {
         thickSlicesNum = intProperty->GetValue();
         if(thickSlicesNum < 1) thickSlicesNum=1;
         if(thickSlicesNum > 10) thickSlicesNum=10;
       }
     }
     else
     {
       MITK_WARN << "no associated widget plane data tree node found";
     }
   }
 
   const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( worldGeometry );
 
   if(thickSlicesMode > 0)
   {
     double dataZSpacing = 1.0;
 
     Vector3D normInIndex, normal;
 
     if ( planeGeometry != NULL ){
       normal = planeGeometry->GetNormal();
     }else{
       const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * >(worldGeometry);
       if(abstractGeometry != NULL)
         normal = abstractGeometry->GetPlane()->GetNormal();
       else
         return; //no fitting geometry set
     }
     normal.Normalize();
 
-    input->GetTimeSlicedGeometry()->GetGeometry3D( this->GetTimestep() )->WorldToIndex( normal, normInIndex );
+    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->SetInput( 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
   vtkFloatingPointType 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
   {
     vtkFloatingPointType 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->SetInput(localStorage->m_ReslicedImage);
 
     localStorage->m_LevelWindowFilter->SetInputConnection(localStorage->m_VectorComponentExtractor->GetOutputPort(0));
   }
   else
   {
     //connect the input with the levelwindow filter
     localStorage->m_LevelWindowFilter->SetInput(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->SetInput(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::LEVELWINDOW_COLOR;
     mitk::RenderingModeProperty::Pointer mode = dynamic_cast<mitk::RenderingModeProperty*>(this->GetDataNode()->GetProperty( "Image Rendering.Mode", renderer ));
     if(mode.IsNotNull())
     {
       renderingMode = mode->GetRenderingMode();
     }
     switch(renderingMode)
     {
     case mitk::RenderingModeProperty::LEVELWINDOW_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_Color";
       localStorage->m_LevelWindowFilter->SetLookupTable( localStorage->m_DefaultLookupTable );
       this->ApplyLevelWindow( renderer );
       break;
     case mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_LookupTable_Color";
       this->ApplyLookuptable( renderer );
       this->ApplyLevelWindow( renderer );
       break;
     case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_ColorTransferFunction_Color";
       this->ApplyColorTransferFunction( renderer );
       this->ApplyLevelWindow( renderer );
       break;
     case mitk::RenderingModeProperty::LOOKUPTABLE_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = LookupTable_Color";
       this->ApplyLookuptable( renderer );
       break;
     case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR:
       MITK_DEBUG << "'Image Rendering.Mode' = ColorTransferFunction_Color";
       this->ApplyColorTransferFunction( renderer );
       break;
     default:
       MITK_ERROR << "No valid 'Image Rendering.Mode' set";
       break;
     }
   }
   //we apply color for all images (including binaries).
   this->ApplyColor( renderer );
 }
 
 void mitk::ImageVtkMapper2D::ApplyLookuptable( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
   vtkLookupTable* usedLookupTable = localStorage->m_ColorLookupTable;
 
   // If lookup table or transferfunction use is requested...
   mitk::LookupTableProperty::Pointer lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
 
   if( lookupTableProp.IsNotNull() ) // is a lookuptable set?
   {
     usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
   }
   else
   {
     MITK_WARN << "Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'. A default (rainbow) lookup table will be used.";
   }
   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 TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
+  const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
-       || ( dataTimeGeometry->GetTimeSteps() == 0 )
-       || ( !dataTimeGeometry->IsValidTime( this->GetTimestep() ) ) )
+    || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 )
+    || ( !dataTimeGeometry->IsValidTimeStep( this->GetTimestep() ) ) )
   {
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   //check if something important has changed and we need to rerender
   if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
        || (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
        || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
        || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
        || (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
        || (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
   {
     this->GenerateDataForRenderer( renderer );
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
 
   // Properties common for both images and segmentations
   node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
   node->AddProperty( "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "outline width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
   node->AddProperty( "outline binary shadow", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "outline binary shadow color", ColorProperty::New(0.0,0.0,0.0), renderer, overwrite );
   node->AddProperty( "outline shadow width", mitk::FloatProperty::New( 1.5 ), renderer, overwrite );
   if(image->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
   else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
   node->AddProperty( "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) );  // set to user configurable default value (see global options)
   node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
   node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
 
   mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
   node->AddProperty( "Image Rendering.Mode", renderingModeProperty);
 
   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
     {
       // generate LUT (white to black)
       mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
       vtkLookupTable* bwLut = mitkLut->GetVtkLookupTable();
       bwLut->SetTableRange (0, 1);
       bwLut->SetSaturationRange (0, 0);
       bwLut->SetHueRange (0, 0);
       bwLut->SetValueRange (1, 0);
       bwLut->SetAlphaRange (1, 1);
       bwLut->SetRampToLinear();
       bwLut->Build();
       mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty( "LookupTable", mitkLutProp );
     }
     else
       if ( photometricInterpretation.find("MONOCHROME2") != std::string::npos ) // meaning: display MINIMUM pixels as BLACK
       {
         // apply default LUT (black to white)
         node->SetProperty( "color", mitk::ColorProperty::New( 1,1,1 ), renderer );
       }
     // PALETTE interpretation should be handled ok by RGB loading
   }
 
   bool isBinaryImage(false);
   if ( ! node->GetBoolProperty("binary", isBinaryImage) )
   {
 
     // ok, property is not set, use heuristic to determine if this
     // is a binary image
     mitk::Image::Pointer centralSliceImage;
     ScalarType minValue = 0.0;
     ScalarType maxValue = 0.0;
     ScalarType min2ndValue = 0.0;
     ScalarType max2ndValue = 0.0;
     mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
 
     sliceSelector->SetInput(image);
     sliceSelector->SetSliceNr(image->GetDimension(2)/2);
     sliceSelector->SetTimeNr(image->GetDimension(3)/2);
     sliceSelector->SetChannelNr(image->GetDimension(4)/2);
     sliceSelector->Update();
     centralSliceImage = sliceSelector->GetOutput();
     if ( centralSliceImage.IsNotNull() && centralSliceImage->IsInitialized() )
     {
       minValue    = centralSliceImage->GetStatistics()->GetScalarValueMin();
       maxValue    = centralSliceImage->GetStatistics()->GetScalarValueMax();
       min2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMin();
       max2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMax();
     }
     if ((maxValue == min2ndValue && minValue == max2ndValue) || minValue == maxValue)
     {
       // centralSlice is strange, lets look at all data
       minValue    = image->GetStatistics()->GetScalarValueMin();
       maxValue    = image->GetStatistics()->GetScalarValueMaxNoRecompute();
       min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
       max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
     }
     isBinaryImage = ( maxValue == min2ndValue && minValue == max2ndValue );
   }
 
   // some more properties specific for a binary...
   if (isBinaryImage)
   {
     node->AddProperty( "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite );
     node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.selectedcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.selectedannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.hoveringcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.hoveringannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binary", mitk::BoolProperty::New( true ), renderer, overwrite );
     node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
   }
   else          //...or image type object
   {
     node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
     node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
     node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
     node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
 
     PixelType pixelType = image->GetPixelType();
     std::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 Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry )
 {
   // if either one of the two geometries is NULL we return true
   // for safety reasons
   if ( renderingGeometry == NULL || imageGeometry == NULL )
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance( imageGeometry->GetCornerPoint( 0 ) );
   for( int i=1; i<8; i++ )
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint( i );
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance( cornerPoint );
 
     // if it has not the same signing as the distance of the first point
     if ( initialDistance * distance < 0 )
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 mitk::ImageVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::ImageVtkMapper2D::LocalStorage::LocalStorage()
   : m_VectorComponentExtractor(vtkSmartPointer<vtkImageExtractComponents>::New())
 {
 
   m_LevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
 
   //Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
   m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_BinaryLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
   m_Reslicer = mitk::ExtractSliceFilter::New();
   m_TSFilter = vtkSmartPointer<vtkMitkThickSlicesFilter>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_ReslicedImage = vtkSmartPointer<vtkImageData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   //the following actions are always the same and thus can be performed
   //in the constructor for each image (i.e. the image-corresponding local storage)
   m_TSFilter->ReleaseDataFlagOn();
 
   //built a default lookuptable
   m_DefaultLookupTable->SetRampToLinear();
   m_DefaultLookupTable->SetSaturationRange( 0.0, 0.0 );
   m_DefaultLookupTable->SetHueRange( 0.0, 0.0 );
   m_DefaultLookupTable->SetValueRange( 0.0, 1.0 );
   m_DefaultLookupTable->Build();
 
   m_BinaryLookupTable->SetRampToLinear();
   m_BinaryLookupTable->SetSaturationRange( 0.0, 0.0 );
   m_BinaryLookupTable->SetHueRange( 0.0, 0.0 );
   m_BinaryLookupTable->SetValueRange( 0.0, 1.0 );
   m_BinaryLookupTable->SetRange(0.0, 1.0);
   m_BinaryLookupTable->Build();
 
   // add a default rainbow lookup table for color mapping
   m_ColorLookupTable->SetRampToLinear();
   m_ColorLookupTable->SetHueRange(0.6667, 0.0);
   m_ColorLookupTable->SetTableRange(0.0, 20.0);
   m_ColorLookupTable->Build();
   // make first value transparent
   {
     double rgba[4];
     m_BinaryLookupTable->GetTableValue(0, rgba);
     m_BinaryLookupTable->SetTableValue(0, rgba[0], rgba[1], rgba[2], 0.0); // background to 0
   }
 
   //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/mitkMapper.cpp b/Core/Code/Rendering/mitkMapper.cpp
index 62b7085436..95feeaf3fb 100644
--- a/Core/Code/Rendering/mitkMapper.cpp
+++ b/Core/Code/Rendering/mitkMapper.cpp
@@ -1,164 +1,164 @@
 /*===================================================================
 
 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 "mitkMapper.h"
 #include "mitkDataNode.h"
 #include "mitkBaseRenderer.h"
 #include "mitkProperties.h"
 
 
 mitk::Mapper::Mapper()
   :m_TimeStep( 0 )
 {
 }
 
 
 mitk::Mapper::~Mapper()
 {
 }
 
 
 mitk::BaseData* mitk::Mapper::GetData() const
 {
 return m_DataNode->GetData();
 }
 
 
 mitk::DataNode* mitk::Mapper::GetDataNode() const
 {
   return this->m_DataNode;
 }
 
 
 bool mitk::Mapper::GetColor(float rgb[3], mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetColor(rgb, renderer, name);
 }
 
 bool mitk::Mapper::GetVisibility(bool &visible, mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetVisibility(visible, renderer, name);
 }
 
 bool mitk::Mapper::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetOpacity(opacity, renderer, name);
 }
 
 bool mitk::Mapper::GetLevelWindow(mitk::LevelWindow& levelWindow, mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetLevelWindow(levelWindow, renderer, name);
 }
 
 
 bool mitk::Mapper::IsVisible(mitk::BaseRenderer* renderer, const char* name) const
 {
     bool visible = true;
     GetDataNode()->GetVisibility(visible, renderer, name);
     return visible;
 }
 
 
 void mitk::Mapper::CalculateTimeStep( mitk::BaseRenderer *renderer )
 {
   if ( ( renderer != NULL ) && ( m_DataNode != NULL ) )
   {
     m_TimeStep = renderer->GetTimeStep(m_DataNode->GetData());
   }
   else
   {
     m_TimeStep = 0;
   }
 }
 
 void mitk::Mapper::Update(mitk::BaseRenderer *renderer)
 {
   const DataNode* node = GetDataNode();
 
   assert(node!=NULL);
 
   mitk::BaseData * data = static_cast<mitk::BaseData *>(node->GetData());
 
   if (!data)
     return;
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   // Check if time step is valid
-  const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
+  const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
-    || ( dataTimeGeometry->GetTimeSteps() == 0 )
-    || ( !dataTimeGeometry->IsValidTime( m_TimeStep ) ) )
+    || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 )
+    || ( !dataTimeGeometry->IsValidTimeStep( m_TimeStep ) ) )
   {
-    // TimeSlicedGeometry or time step is not valid for this data:
+    // TimeGeometry or time step is not valid for this data:
     // reset mapper so that nothing is displayed
     this->ResetMapper( renderer );
     return;
   }
 
   this->GenerateDataForRenderer(renderer);
 }
 
 
 bool mitk::Mapper::BaseLocalStorage::IsGenerateDataRequired(
     mitk::BaseRenderer *renderer,
     mitk::Mapper *mapper,
     mitk::DataNode *dataNode) const
 {
   if( mapper && m_LastGenerateDataTime < mapper -> GetMTime () )
     return true;
 
   if( dataNode )
   {
     if( m_LastGenerateDataTime < dataNode -> GetDataReferenceChangedTime () )
       return true;
 
     mitk::BaseData * data = dataNode -> GetData ( ) ;
 
     if( data && m_LastGenerateDataTime < data -> GetMTime ( ) )
       return true;
   }
 
   if( renderer && m_LastGenerateDataTime < renderer -> GetTimeStepUpdateTime ( ) )
     return true;
 
   return false;
 }
 
 void mitk::Mapper::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "layer", mitk::IntProperty::New(0), renderer, overwrite);
   node->AddProperty( "name", mitk::StringProperty::New("No Name!"), renderer, overwrite );
 }
diff --git a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
index e3664c35e8..59ef764078 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 TimeSlicedGeometry of the input object
-    const TimeSlicedGeometry* inputTimeGeometry = input->GetTimeSlicedGeometry();
-    if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
+    // Get the TimeGeometry of the input object
+    const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
+    if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
     {
       return;
     }
 
     //
     // get the world time
     //
     const Geometry2D* worldGeometry = renderer->GetCurrentWorldGeometry2D();
     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->MSToTimeStep( time );
-    if ( inputTimeGeometry->IsValidTime( timeStep ) == false )
+      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);
           glVertex2fv(&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;      glVertex2fv(&tmp[0]);
                tmp=pt2d+vert;      glVertex2fv(&tmp[0]);
                tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
                tmp=pt2d-vert;      glVertex2fv(&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;             glVertex2fv(&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;      glVertex2fv(&tmp[0]);
               tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
               tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
               tmp=pt2d+vert;      glVertex2fv(&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);
            glVertex2fv(&pt2d[0]);
            glVertex2fv(&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/mitkSurfaceGLMapper2D.cpp b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
index 28e61d3c84..3274cb83d4 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
     vtkFloatingPointType dataRange[2] = {0,0};
     vtkFloatingPointType range[2];
 
     Surface::Pointer input  = const_cast< Surface* >(dynamic_cast<const Surface*>( this->GetDataNode()->GetData() ));
     if(input.IsNull()) return;
-    const TimeSlicedGeometry::Pointer inputTimeGeometry = input->GetTimeSlicedGeometry();
-    if(( inputTimeGeometry.IsNull() ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) ) return;
-    for (unsigned int timestep=0; timestep<inputTimeGeometry->GetTimeSteps(); timestep++)
+    const TimeGeometry::Pointer inputTimeGeometry = input->GetTimeGeometry();
+    if(( inputTimeGeometry.IsNull() ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) ) return;
+    for (unsigned int timestep=0; timestep<inputTimeGeometry->GetNumberOfTimeSteps(); 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 TimeSlicedGeometry of the input object
+  // get the TimeGeometry of the input object
   //
-  const TimeSlicedGeometry* inputTimeGeometry = input->GetTimeSlicedGeometry();
-  if(( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
+  const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
+  if(( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 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
   //
   Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
   assert( worldGeometry.IsNotNull() );
 
   ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
   int timestep=0;
 
   if( time > ScalarTypeNumericTraits::NonpositiveMin() )
-    timestep = inputTimeGeometry->MSToTimeStep( time );
+    timestep = inputTimeGeometry->TimePointToTimeStep( time );
 
  // int timestep = this->GetTimestep();
 
-  if( inputTimeGeometry->IsValidTime( timestep ) == false )
+  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.
     vtkFloatingPointType* scalarLimits = m_LUT->GetTableRange();
     vtkFloatingPointType scalarsMin = scalarLimits[0], scalarsMax = scalarLimits[1];
 
     vtkLookupTable *lut;// = vtkLookupTable::New();
 
     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());
       if(worldAbstractGeometry.IsNotNull())
       {
-        AbstractTransformGeometry::ConstPointer surfaceAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(input->GetTimeSlicedGeometry()->GetGeometry3D(0));
+        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;
     }
 
     vtkFloatingPointType 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->SetInput(vtkpolydata);
     m_Cutter->Update();
     //    m_Cutter->GenerateCutScalarsOff();
     //    m_Cutter->SetSortByToSortByCell();
 
     if (m_DrawNormals)
     {
       m_Stripper->SetInput( 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 Geometry2D* 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);
     vtkFloatingPointType 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);
 
       vtkFloatingPointType 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/mitkVolumeDataVtkMapper3D.cpp b/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
index 60530329ef..22b02a96e2 100644
--- a/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
@@ -1,707 +1,707 @@
 /*===================================================================
 
 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 "mitkVolumeDataVtkMapper3D.h"
 
 #include "mitkDataNode.h"
 
 #include "mitkProperties.h"
 #include "mitkLevelWindow.h"
 #include "mitkColorProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkTransferFunctionInitializer.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkRenderingManager.h"
 
 
 #include <vtkActor.h>
 #include <vtkProperty.h>
 #include <vtkVolumeRayCastMapper.h>
 
 #include <vtkVolumeTextureMapper2D.h>
 #include <vtkVolume.h>
 #include <vtkVolumeProperty.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkPiecewiseFunction.h>
 #include <vtkVolumeRayCastCompositeFunction.h>
 #include <vtkVolumeRayCastMIPFunction.h>
 #include <vtkFiniteDifferenceGradientEstimator.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkImageShiftScale.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkImageWriter.h>
 #include <vtkImageData.h>
 #include <vtkLODProp3D.h>
 #include <vtkImageResample.h>
 #include <vtkPlane.h>
 #include <vtkImplicitPlaneWidget.h>
 #include <vtkAssembly.h>
 
 #include <vtkCubeSource.h>
 #include <vtkPolyDataMapper.h>
 #include "mitkVtkVolumeRenderingProperty.h"
 
 
 #include <itkMultiThreader.h>
 
 const mitk::Image* mitk::VolumeDataVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::Image*> ( GetDataNode()->GetData() );
 }
 
 mitk::VolumeDataVtkMapper3D::VolumeDataVtkMapper3D()
 : m_Mask( NULL )
 {
   m_PlaneSet = false;
 
   m_ClippingPlane = vtkPlane::New();
   m_PlaneWidget = vtkImplicitPlaneWidget::New();
 
   /*
   m_T2DMapper =  vtkVolumeTextureMapper2D::New();
   m_T2DMapper->SetMaximumNumberOfPlanes( 100 );
 */
   m_HiResMapper = vtkVolumeRayCastMapper::New();
   m_HiResMapper->SetSampleDistance(1.0); // 4 rays for every pixel
 
   m_HiResMapper->IntermixIntersectingGeometryOn();
   m_HiResMapper->SetNumberOfThreads( itk::MultiThreader::GetGlobalDefaultNumberOfThreads() );
   /*
   vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
   compositeFunction->SetCompositeMethodToClassifyFirst();
   m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
   compositeFunction->Delete();
 
   vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
   m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
   mipFunction->Delete();
  */
 
   vtkFiniteDifferenceGradientEstimator* gradientEstimator =
   vtkFiniteDifferenceGradientEstimator::New();
   m_HiResMapper->SetGradientEstimator(gradientEstimator);
   gradientEstimator->Delete();
 
   m_VolumePropertyLow = vtkVolumeProperty::New();
   m_VolumePropertyMed = vtkVolumeProperty::New();
   m_VolumePropertyHigh = vtkVolumeProperty::New();
 
   m_VolumeLOD = vtkLODProp3D::New();
   m_VolumeLOD->VisibilityOff();
 
   m_HiResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyHigh,0.0); // RayCast
 
 //  m_LowResID = m_VolumeLOD->AddLOD(m_T2DMapper,m_VolumePropertyLow,0.0); // TextureMapper2D
 
 
   m_MedResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyMed,0.0); // RayCast
 
 
   m_Resampler = vtkImageResample::New();
   m_Resampler->SetAxisMagnificationFactor(0,0.25);
   m_Resampler->SetAxisMagnificationFactor(1,0.25);
   m_Resampler->SetAxisMagnificationFactor(2,0.25);
 
   // For abort rendering mechanism
   m_VolumeLOD->AutomaticLODSelectionOff();
 
 
   m_BoundingBox = vtkCubeSource::New();
   m_BoundingBox->SetXLength( 0.0 );
   m_BoundingBox->SetYLength( 0.0 );
   m_BoundingBox->SetZLength( 0.0 );
 
   m_BoundingBoxMapper = vtkPolyDataMapper::New();
   m_BoundingBoxMapper->SetInput( m_BoundingBox->GetOutput() );
 
   m_BoundingBoxActor = vtkActor::New();
   m_BoundingBoxActor->SetMapper( m_BoundingBoxMapper );
   m_BoundingBoxActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
   m_BoundingBoxActor->GetProperty()->SetRepresentationToWireframe();
 
 
   // BoundingBox rendering is not working due to problem with assembly
   // transformation; see bug #454
   // If commenting in the following, do not forget to comment in the
   // m_Prop3DAssembly->Delete() line in the destructor.
   //m_Prop3DAssembly = vtkAssembly::New();
   //m_Prop3DAssembly->AddPart( m_VolumeLOD );
   //m_Prop3DAssembly->AddPart( m_BoundingBoxActor );
   //m_Prop3D = m_Prop3DAssembly;
 
   m_ImageCast = vtkImageShiftScale::New();
   m_ImageCast->SetOutputScalarTypeToUnsignedShort();
   m_ImageCast->ClampOverflowOn();
 
   m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
   m_UnitSpacingImageFilter->SetInput(m_ImageCast->GetOutput());
   m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
 
   m_ImageMaskFilter = vtkImageMask::New();
   m_ImageMaskFilter->SetMaskedOutputValue(0xffff);
 
   this->m_Resampler->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
   this->m_HiResMapper->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
 
 //  m_T2DMapper->SetInput(m_Resampler->GetOutput());
 
 
   this->CreateDefaultTransferFunctions();
 }
 
 vtkProp *mitk::VolumeDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
 {
   return m_VolumeLOD;
 }
 
 mitk::VolumeDataVtkMapper3D::~VolumeDataVtkMapper3D()
 {
   m_UnitSpacingImageFilter->Delete();
   m_ImageCast->Delete();
 //  m_T2DMapper->Delete();
   m_HiResMapper->Delete();
   m_Resampler->Delete();
   m_VolumePropertyLow->Delete();
   m_VolumePropertyMed->Delete();
   m_VolumePropertyHigh->Delete();
   m_VolumeLOD->Delete();
   m_ClippingPlane->Delete();
   m_PlaneWidget->Delete();
   // m_Prop3DAssembly->Delete();
   m_BoundingBox->Delete();
   m_BoundingBoxMapper->Delete();
   m_BoundingBoxActor->Delete();
   m_ImageMaskFilter->Delete();
   m_DefaultColorTransferFunction->Delete();
   m_DefaultOpacityTransferFunction->Delete();
   m_DefaultGradientTransferFunction->Delete();
 
   if (m_Mask)
   {
     m_Mask->Delete();
   }
 }
 
 void mitk::VolumeDataVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   SetVtkMapperImmediateModeRendering(m_BoundingBoxMapper);
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
   if ( !input || !input->IsInitialized() )
     return;
 
   vtkRenderWindow* renderWindow = renderer->GetRenderWindow();
 
   bool volumeRenderingEnabled = true;
 
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible ||
       this->GetDataNode() == NULL ||
       dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))==NULL ||
       dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == false
     )
   {
     volumeRenderingEnabled = false;
 
     // Check if a bounding box should be displayed around the dataset
     // (even if volume rendering is disabled)
     bool hasBoundingBox = false;
     this->GetDataNode()->GetBoolProperty( "bounding box", hasBoundingBox );
 
     if ( !hasBoundingBox )
     {
       m_BoundingBoxActor->VisibilityOff();
     }
     else
     {
       m_BoundingBoxActor->VisibilityOn();
 
       const BoundingBox::BoundsArrayType &bounds =
-        input->GetTimeSlicedGeometry()->GetBounds();
+        input->GetTimeGeometry()->GetBoundsInWorld();
 
       m_BoundingBox->SetBounds(
         bounds[0], bounds[1],
         bounds[2], bounds[3],
         bounds[4], bounds[5] );
 
       ColorProperty *colorProperty;
       if ( this->GetDataNode()->GetProperty(
         colorProperty, "color" ) )
       {
         const mitk::Color &color = colorProperty->GetColor();
         m_BoundingBoxActor->GetProperty()->SetColor(
           color[0], color[1], color[2] );
       }
       else
       {
         m_BoundingBoxActor->GetProperty()->SetColor(
           1.0, 1.0, 1.0 );
       }
     }
   }
 
   // Don't do anything if VR is disabled
   if ( !volumeRenderingEnabled )
   {
     m_VolumeLOD->VisibilityOff();
     return;
   }
   else
   {
         mitk::VtkVolumeRenderingProperty* vrp=dynamic_cast<mitk::VtkVolumeRenderingProperty*>(GetDataNode()->GetProperty("volumerendering configuration",renderer));
         if(vrp)
         {
           int renderingValue = vrp->GetValueAsId();
 
           switch(renderingValue)
           {
               case  VTK_VOLUME_RAY_CAST_MIP_FUNCTION:
               {
                   vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
                   m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
                   mipFunction->Delete();
                   MITK_INFO <<"in switch" <<std::endl;
                   break;
               }
 
               case VTK_RAY_CAST_COMPOSITE_FUNCTION:
               {
                   vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
                   compositeFunction->SetCompositeMethodToClassifyFirst();
                   m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
                   compositeFunction->Delete();
                   break;
               }
               default:
                   MITK_ERROR <<"Warning: invalid volume rendering option.  " << std::endl;
 
           }
         }
     m_VolumeLOD->VisibilityOn();
   }
 
   this->SetPreferences();
 /*
   switch ( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) )
   {
   case 0:
     m_VolumeLOD->SetSelectedLODID(m_MedResID);  m_LowResID );
     break;
 
   default:
   case 1:
     m_VolumeLOD->SetSelectedLODID( m_HiResID );
     break;
   }
 */
   m_VolumeLOD->SetSelectedLODID( m_HiResID );
 
-  assert(input->GetTimeSlicedGeometry());
+  assert(input->GetTimeGeometry());
 
   const Geometry3D* worldgeometry = renderer->GetCurrentWorldGeometry();
   if(worldgeometry==NULL)
   {
     GetDataNode()->SetProperty("volumerendering",mitk::BoolProperty::New(false));
     return;
   }
 
   vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
   if(inputData==NULL)
     return;
 
 
   m_ImageCast->SetInput( inputData );
 
   //If mask exists, process mask before resampling.
   if (this->m_Mask)
   {
     this->m_ImageMaskFilter->SetImageInput(this->m_UnitSpacingImageFilter->GetOutput());
     this->m_Resampler->SetInput(this->m_ImageMaskFilter->GetOutput());
     this->m_HiResMapper->SetInput(this->m_ImageMaskFilter->GetOutput());
   }
   else
   {
     this->m_Resampler->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
     this->m_HiResMapper->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
   }
 
   this->UpdateTransferFunctions( renderer );
 
   vtkRenderWindowInteractor *interactor = renderWindow->GetInteractor();
 
   float frameRate;
   if( this->GetDataNode()->GetFloatProperty( "framerate", frameRate ) && frameRate > 0 && frameRate <= 60)
   {
     interactor->SetDesiredUpdateRate(  frameRate );
     interactor->SetStillUpdateRate( frameRate );
   }
   else if( frameRate > 60 )
   {
     this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(60));
     interactor->SetDesiredUpdateRate(  60 );
     interactor->SetStillUpdateRate( 60 );
   }
   else
   {
     this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(0.00001));
     interactor->SetDesiredUpdateRate(  0.00001 );
     interactor->SetStillUpdateRate( 0.00001 );
   }
 
   if ( m_RenderWindowInitialized.find( renderWindow ) == m_RenderWindowInitialized.end() )
   {
     m_RenderWindowInitialized.insert( renderWindow );
 
 //    mitk::RenderingManager::GetInstance()->SetNextLOD( 0, renderer );
 
     mitk::RenderingManager::GetInstance()->SetShading( true, 0 );
     mitk::RenderingManager::GetInstance()->SetShading( true, 1 );
     //mitk::RenderingManager::GetInstance()->SetShading( true, 2 );
 
     mitk::RenderingManager::GetInstance()->SetShadingValues(
       m_VolumePropertyHigh->GetAmbient(),
       m_VolumePropertyHigh->GetDiffuse(),
       m_VolumePropertyHigh->GetSpecular(),
       m_VolumePropertyHigh->GetSpecularPower());
 
     mitk::RenderingManager::GetInstance()->SetClippingPlaneStatus(false);
   }
 
   this->SetClippingPlane( interactor );
 }
 
 
 void mitk::VolumeDataVtkMapper3D::CreateDefaultTransferFunctions()
 {
   m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New();
   m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
   m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 );
   m_DefaultOpacityTransferFunction->ClampingOn();
 
   m_DefaultGradientTransferFunction = vtkPiecewiseFunction::New();
   m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 );
   m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 );
   m_DefaultGradientTransferFunction->ClampingOn();
 
   m_DefaultColorTransferFunction = vtkColorTransferFunction::New();
   m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
   m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 );
   m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 );
   m_DefaultColorTransferFunction->ClampingOn();
 }
 
 void mitk::VolumeDataVtkMapper3D::UpdateTransferFunctions( mitk::BaseRenderer *renderer )
 {
   vtkPiecewiseFunction *opacityTransferFunction = NULL;
   vtkPiecewiseFunction *gradientTransferFunction = NULL;
   vtkColorTransferFunction *colorTransferFunction = NULL;
 
   mitk::LookupTableProperty::Pointer lookupTableProp;
   lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
   mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction"));
 
   if ( transferFunctionProp.IsNotNull() )   {
 
     opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
     gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
     colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
   }
   else if (lookupTableProp.IsNotNull() )
   {
     lookupTableProp->GetLookupTable()->CreateOpacityTransferFunction(opacityTransferFunction);
     opacityTransferFunction->ClampingOn();
     lookupTableProp->GetLookupTable()->CreateGradientTransferFunction(gradientTransferFunction);
     gradientTransferFunction->ClampingOn();
     lookupTableProp->GetLookupTable()->CreateColorTransferFunction(colorTransferFunction);
     colorTransferFunction->ClampingOn();
   }
   else
   {
     opacityTransferFunction = m_DefaultOpacityTransferFunction;
     gradientTransferFunction = m_DefaultGradientTransferFunction;
     colorTransferFunction = m_DefaultColorTransferFunction;
 
     float rgb[3]={1.0f,1.0f,1.0f};
     // check for color prop and use it for rendering if it exists
     if(GetDataNode()->GetColor(rgb, renderer, "color"))
     {
       colorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
       colorTransferFunction->AddRGBPoint( 127.5, rgb[0], rgb[1], rgb[2] );
       colorTransferFunction->AddRGBPoint( 255.0, rgb[0], rgb[1], rgb[2] );
     }
   }
 
   if (this->m_Mask)
   {
     opacityTransferFunction->AddPoint(0xffff, 0.0);
   }
 
   m_VolumePropertyLow->SetColor( colorTransferFunction );
   m_VolumePropertyLow->SetScalarOpacity( opacityTransferFunction );
   m_VolumePropertyLow->SetGradientOpacity( gradientTransferFunction );
   m_VolumePropertyLow->SetInterpolationTypeToNearest();
 
   m_VolumePropertyMed->SetColor( colorTransferFunction );
   m_VolumePropertyMed->SetScalarOpacity( opacityTransferFunction );
   m_VolumePropertyMed->SetGradientOpacity( gradientTransferFunction );
   m_VolumePropertyMed->SetInterpolationTypeToNearest();
 
   m_VolumePropertyHigh->SetColor( colorTransferFunction );
   m_VolumePropertyHigh->SetScalarOpacity( opacityTransferFunction );
   m_VolumePropertyHigh->SetGradientOpacity( gradientTransferFunction );
   m_VolumePropertyHigh->SetInterpolationTypeToLinear();
 }
 
 
 /* Shading enabled / disabled */
 void mitk::VolumeDataVtkMapper3D::SetPreferences()
 {
   //LOD 0
   /*if(mitk::RenderingManager::GetInstance()->GetShading(0))
   {
     m_VolumePropertyLow->ShadeOn();
     m_VolumePropertyLow->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
     m_VolumePropertyLow->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
     m_VolumePropertyLow->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
     m_VolumePropertyLow->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
   }
   else*/
   {
     m_VolumePropertyLow->ShadeOff();
   }
 
   //LOD 1
   /*if(mitk::RenderingManager::GetInstance()->GetShading(1))
   {
     m_VolumePropertyMed->ShadeOn();
     m_VolumePropertyMed->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
     m_VolumePropertyMed->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
     m_VolumePropertyMed->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
     m_VolumePropertyMed->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
   }
   else*/
   {
     m_VolumePropertyMed->ShadeOff();
   }
 
   //LOD 2
   /*
   if(mitk::RenderingManager::GetInstance()->GetShading(2))
   {
     m_VolumePropertyHigh->ShadeOn();
     //Shading Properties
     m_VolumePropertyHigh->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
     m_VolumePropertyHigh->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
     m_VolumePropertyHigh->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
     m_VolumePropertyHigh->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
   }
   else
   {
     m_VolumePropertyHigh->ShadeOff();
   }
   */
 
 }
 
 /* Adds A Clipping Plane to the Mapper */
 void mitk::VolumeDataVtkMapper3D::SetClippingPlane(vtkRenderWindowInteractor* interactor)
 {
 
   if(mitk::RenderingManager::GetInstance()->GetClippingPlaneStatus()) //if clipping plane is enabled
   {
 
     if(!m_PlaneSet)
     {
     m_PlaneWidget->SetInteractor(interactor);
     m_PlaneWidget->SetPlaceFactor(1.0);
     m_PlaneWidget->SetInput(m_UnitSpacingImageFilter->GetOutput());
     m_PlaneWidget->OutlineTranslationOff(); //disables scaling of the bounding box
     m_PlaneWidget->ScaleEnabledOff(); //disables scaling of the bounding box
     m_PlaneWidget->DrawPlaneOff(); //clipping plane is transparent
     mitk::Image* input  = const_cast<mitk::Image *>(this->GetInput());
 
     /*places the widget within the specified bounds*/
     m_PlaneWidget->PlaceWidget(
         input->GetGeometry()->GetOrigin()[0],(input->GetGeometry()->GetOrigin()[0])+(input->GetDimension(0))*(input->GetVtkImageData()->GetSpacing()[0]),                               input->GetGeometry()->GetOrigin()[1],(input->GetGeometry()->GetOrigin()[1])+(input->GetDimension(1))*(input->GetVtkImageData()->GetSpacing()[1]),                               input->GetGeometry()->GetOrigin()[2],(input->GetGeometry()->GetOrigin()[2])+(input->GetDimension(2))*(input->GetVtkImageData()->GetSpacing()[2]));
 
 //    m_T2DMapper->AddClippingPlane(m_ClippingPlane);
     m_HiResMapper->AddClippingPlane(m_ClippingPlane);
     }
 
     m_PlaneWidget->GetPlane(m_ClippingPlane);
     m_PlaneSet = true;
   }
   else //if clippingplane is disabled
   {
     if(m_PlaneSet) //if plane exists
     {
     DelClippingPlane();
     }
   }
 
 }
 
 
 /* Removes the clipping plane */
 void mitk::VolumeDataVtkMapper3D::DelClippingPlane()
 {
 //  m_T2DMapper->RemoveAllClippingPlanes();
   m_HiResMapper->RemoveAllClippingPlanes();
   m_PlaneSet = false;
 }
 
 
 void mitk::VolumeDataVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "volumerendering configuration", mitk::VtkVolumeRenderingProperty::New( 1 ), renderer, overwrite );
   node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if(image.IsNotNull() && image->IsInitialized())
   {
     if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
     {
       mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
       mitk::LevelWindow levelwindow;
       levelwindow.SetAuto( image );
       levWinProp->SetLevelWindow( levelwindow );
       node->SetProperty( "levelwindow", levWinProp, renderer );
     }
     //This mapper used to set a default lut "LookupTable" for images. However, this will
     //overwrite the default lut of the 2D image mapper. Thus, this property here is renamed.
     /*
     if((overwrite) || (node->GetProperty("Volume.LookupTable", renderer)==NULL))
     {
       // add a default rainbow lookup table for color mapping
       mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
       vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
       vtkLut->SetHueRange(0.6667, 0.0);
       vtkLut->SetTableRange(0.0, 20.0);
       vtkLut->Build();
       mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty( "Volume.LookupTable", mitkLutProp );
     }*/
     if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL))
     {
       // add a default transfer function
       mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
       mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
       tfInit->SetTransferFunctionMode(0);
       node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
     }
   }
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 
 bool mitk::VolumeDataVtkMapper3D::IsLODEnabled( mitk::BaseRenderer * /*renderer*/ ) const
 {
   return false;
 
 
   // Volume mapper is LOD enabled if volumerendering is enabled
   /*
   return
     dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer)) != NULL &&
     dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == true;
   */
 }
 
 
 void mitk::VolumeDataVtkMapper3D::EnableMask()
 {
   if (!this->m_Mask)
   {
     const Image *orig_image = this->GetInput();
     unsigned int *dimensions = orig_image->GetDimensions();
 
     this->m_Mask = vtkImageData::New();
     this->m_Mask->SetDimensions(dimensions[0], dimensions[1], dimensions[2]);
     this->m_Mask->SetScalarTypeToUnsignedChar();
     this->m_Mask->SetNumberOfScalarComponents(1);
     this->m_Mask->AllocateScalars();
 
     unsigned char *mask_data = static_cast<unsigned char*>(this->m_Mask->GetScalarPointer());
     unsigned int size = dimensions[0] * dimensions[1] * dimensions[2];
 
     for (unsigned int i = 0u; i < size; ++i)
     {
       *mask_data++ = 1u;
     }
     this->m_ImageMaskFilter->SetMaskInput(this->m_Mask);
     this->m_ImageMaskFilter->Modified();
   }
 }
 
 void mitk::VolumeDataVtkMapper3D::DisableMask()
 {
   if (this->m_Mask)
   {
     this->m_Mask->Delete();
     this->m_Mask = 0;
   }
 }
 
 mitk::Image::Pointer mitk::VolumeDataVtkMapper3D::GetMask()
 {
   if (this->m_Mask)
   {
     Image::Pointer mask = Image::New();
 
     mask->Initialize(this->m_Mask);
     mask->SetImportVolume(this->m_Mask->GetScalarPointer(), 0, 0, Image::ReferenceMemory);
     mask->SetGeometry(this->GetInput()->GetGeometry());
     return mask;
   }
 
   return 0;
 }
 
 void mitk::VolumeDataVtkMapper3D::UpdateMask()
 {
   if (this->m_Mask)
   {
     this->m_ImageMaskFilter->Modified();
   }
 }
 
 bool mitk::VolumeDataVtkMapper3D::SetMask(const mitk::Image* mask)
 {
   if (this->m_Mask)
   {
     if ( (mask->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR)
          &&(mask->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR ))
     {
       Image *img = const_cast<Image*>(mask);
 
       this->m_Mask->DeepCopy(img->GetVtkImageData());
       this->m_ImageMaskFilter->Modified();
       return true;
     }
   }
 
   return false;
 }
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.cpp b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
index 3e36cad61f..97f0aadc91 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.cpp
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
@@ -1,1005 +1,1005 @@
 /*===================================================================
 
 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 "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 )
   : BaseRenderer(name,renWin, rm),
   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);
 
   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() );
 
   // 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::TimeSlicedGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D( NULL, "includeInBoundingBox" );
+  mitk::TimeGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D( NULL, "includeInBoundingBox" );
 
   if ( geometry.IsNull() )
     return false;
 
-  this->SetWorldGeometry(geometry);
+  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(renWin);
       }
    }
 }
 
 
 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 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() );
     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;
 }
diff --git a/Core/Code/Testing/files.cmake b/Core/Code/Testing/files.cmake
index 61f65fd36f..d1e2213c98 100644
--- a/Core/Code/Testing/files.cmake
+++ b/Core/Code/Testing/files.cmake
@@ -1,168 +1,168 @@
 
 # tests with no extra command line parameter
 set(MODULE_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
   #mitkImageMapper2DTest.cpp
   mitkImageGeneratorTest.cpp
   mitkBaseDataTest.cpp
   #mitkImageToItkTest.cpp
   mitkImportItkImageTest.cpp
   mitkGrabItkImageMemoryTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkInteractorTest.cpp
   #mitkITKThreadingTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   #mitkPipelineSmartPointerCorrectnessTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetEqualTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetReaderTest.cpp
   mitkPointSetInteractorTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   #mitkRegistrationBaseTest.cpp
   #mitkSegmentationInterpolationTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkStateMachineTest.cpp
   ##mitkStateMachineContainerTest.cpp ## rewrite test, indirect since no longer exported Bug 14529
   mitkStateTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceEqualTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
-  mitkTimeSlicedGeometryTest.cpp
+  mitkTimeGeometryTest.cpp
   mitkTransitionTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   #mitkAbstractTransformGeometryTest.cpp
   mitkStepperTest.cpp
   itkTotalVariationDenoisingImageFilterTest.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
 )
 
 # 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
     #mitkLabeledImageToSurfaceFilterTest.cpp
     #mitkExternalToolsTest.cpp
     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
     mitkIOUtilTest.cpp
     mitkSurfaceVtkMapper3DTest
     mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
     mitkSurfaceGLMapper2DColorTest.cpp
     mitkSurfaceGLMapper2DOpacityTest.cpp
     mitkVolumeCalculatorTest.cpp
     mitkLevelWindowManagerTest.cpp
     mitkPointSetVtkMapper2DTest.cpp
     mitkPointSetVtkMapper2DImageTest.cpp
     mitkPointSetVtkMapper2DGlyphTypeTest.cpp
     mitkLabelOverlay3DRendering2DTest.cpp
     mitkLabelOverlay3DRendering3DTest.cpp
     mitkTextOverlay2DRenderingTest.cpp
     mitkTextOverlay2DLayouterRenderingTest.cpp
     mitkTextOverlay3DRendering2DTest.cpp
     mitkTextOverlay3DRendering3DTest.cpp
     mitkTextOverlay3DColorRenderingTest.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/mitkAbstractTransformGeometryTest.cpp b/Core/Code/Testing/mitkAbstractTransformGeometryTest.cpp
index fdb6db55a6..7278a3109d 100644
--- a/Core/Code/Testing/mitkAbstractTransformGeometryTest.cpp
+++ b/Core/Code/Testing/mitkAbstractTransformGeometryTest.cpp
@@ -1,205 +1,204 @@
 /*===================================================================
 
 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 "mitkExternAbstractTransformGeometry.h"
 #include "mitkPlaneGeometry.h"
-#include "mitkTimeSlicedGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 #include <vtkSphericalTransform.h>
 
 #include <fstream>
 
 int mitkAbstractTransformGeometryTest(int /*argc*/, char* /*argv*/ [])
 {
   mitk::Point3D origin;
   mitk::Vector3D right, bottom;
   mitk::ScalarType width, height;
   mitk::ScalarType widthInMM, heightInMM;
 
   std::cout << "Initializing an x-/y-plane (xyPlane) as parameter plane by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
   mitk::PlaneGeometry::Pointer xyPlane = mitk::PlaneGeometry::New();
   width  = 100;    widthInMM  = width;
   height = 200;    heightInMM = height;
   mitk::ScalarType bounds[6] = {0, width, 0, height, 0, 1};
   mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
   mitk::FillVector3D(right,  widthInMM,          0, 0);
   mitk::FillVector3D(bottom,         0, heightInMM, 0);
   xyPlane->InitializeStandardPlane(right, bottom);
   xyPlane->SetOrigin(origin);
   xyPlane->SetSizeInUnits(width, height);
 
   std::cout << "Creating AbstractTransformGeometry: " <<std::endl;
   mitk::ExternAbstractTransformGeometry::Pointer abstractgeometry=mitk::ExternAbstractTransformGeometry::New();
 
   std::cout << "Setting xyPlane as parameter plane of AbstractTransformGeometry: "<<std::endl;
   abstractgeometry->SetPlane(xyPlane);
 
   std::cout << "Testing whether the bounds of xyPlane and the parametric bounds of AbstractTransformGeometry are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(xyPlane->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(xyPlane->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing whether the parametic bounds of AbstractTransformGeometry and the bounds of the plane accessed from there are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Change parametic bounds of AbstractTransformGeometry and test whether they are equal to the bounds of the plane accessed from there: "<<std::endl;
   height = 300;
   bounds[3] = height;
   abstractgeometry->SetParametricBounds(bounds);
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
 
   std::cout << "Initializing an phi-/theta-plane (sphereParameterPlane) as parameter plane by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
   mitk::PlaneGeometry::Pointer sphereParameterPlane = mitk::PlaneGeometry::New();
   width  = 100;    widthInMM  = 2*vnl_math::pi;
   height = 200;    heightInMM =   vnl_math::pi;
   mitk::ScalarType radiusInMM = 2.5;
 
   mitk::FillVector3D(origin, radiusInMM,          0,  widthInMM);
   mitk::FillVector3D(right,  0,                   0, -widthInMM);
   mitk::FillVector3D(bottom, 0,          heightInMM,          0);
   sphereParameterPlane->InitializeStandardPlane(right, bottom);
   sphereParameterPlane->SetOrigin(origin);
   sphereParameterPlane->SetSizeInUnits(width, height);
 
   std::cout << "Creating an vtkSphericalTransform (sphericalTransform) to use with sphereParameterPlane: "<<std::endl;
   vtkSphericalTransform* sphericalTransform = vtkSphericalTransform::New();
 
   std::cout << "Setting sphereParameterPlane as parameter plane and sphericalTransform as transform of AbstractTransformGeometry: "<<std::endl;
   abstractgeometry->SetPlane(sphereParameterPlane);
   abstractgeometry->SetVtkAbstractTransform(sphericalTransform);
 
   std::cout << "Testing whether the bounds of sphereParameterPlane and the parametric bounds of AbstractTransformGeometry are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(sphereParameterPlane->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(sphereParameterPlane->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing whether the parametic bounds of AbstractTransformGeometry and the bounds of the plane accessed from there are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mapping Map(pt2d_mm(phi=Pi,theta=Pi/2.0), pt3d_mm) and compare with expected (-radius, 0, 0): ";
   mitk::Point2D pt2d_mm;
   mitk::Point3D pt3d_mm, expected_pt3d_mm;
   pt2d_mm[0] = vnl_math::pi; pt2d_mm[1] = vnl_math::pi_over_2;
   mitk::FillVector3D(expected_pt3d_mm, -radiusInMM, 0, 0);
   abstractgeometry->Map(pt2d_mm, pt3d_mm);
   if(mitk::Equal(pt3d_mm, expected_pt3d_mm) == 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;
   abstractgeometry->Map(pt3d_mm, testpt2d_mm);
   if(mitk::Equal(pt2d_mm, testpt2d_mm) == 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;
   abstractgeometry->IndexToWorld(pt2d_units, testpt2d_mm);
   if(mitk::Equal(pt2d_mm, testpt2d_mm) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Change parametic bounds of AbstractTransformGeometry and test whether they are equal to the bounds of the plane accessed from there: "<<std::endl;
   height = 300;
   bounds[3] = height;
   abstractgeometry->SetParametricBounds(bounds);
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==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: ";
   pt2d_units[0] = width/2.0;     pt2d_units[1] = height/2.0;
   pt2d_mm[0]    = widthInMM/2.0; pt2d_mm[1]    = heightInMM/2.0;
   abstractgeometry->IndexToWorld(pt2d_units, testpt2d_mm);
   if(mitk::Equal(pt2d_mm, testpt2d_mm) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
   //std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the SlicedGeometry3D: ";
   //mitk::PlaneGeometry* accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(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: "<<std::endl;
   //if((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0))==false) ||
   //   (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
   //   (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false))
   //{
   //  std::cout<<"[FAILED]"<<std::endl;
   //  return EXIT_FAILURE;
   //}
   //std::cout<<"[PASSED]"<<std::endl;
 
   sphericalTransform->Delete();
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
diff --git a/Core/Code/Testing/mitkAbstractTransformPlaneGeometryTest.cpp b/Core/Code/Testing/mitkAbstractTransformPlaneGeometryTest.cpp
index a48bd51d6c..f2e86dcc78 100644
--- a/Core/Code/Testing/mitkAbstractTransformPlaneGeometryTest.cpp
+++ b/Core/Code/Testing/mitkAbstractTransformPlaneGeometryTest.cpp
@@ -1,207 +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 "mitkImage.h"
 #include "mitkVtkAbstractTransformPlaneGeometry.h"
 #include "mitkPlaneGeometry.h"
-#include "mitkTimeSlicedGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 #include <vtkSphericalTransform.h>
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.txx>
 
 #include <fstream>
 
 int mitkVtkAbstractTransformPlaneGeometryTest(int argc, char* argv[])
 {
   mitk::Point3D origin;
   mitk::Vector3D right, bottom;
   mitk::ScalarType width, height;
   mitk::ScalarType widthInMM, heightInMM;
 
   std::cout << "Initializing an x-/y-plane (xyPlane) as parameter plane by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
   mitk::PlaneGeometry::Pointer xyPlane = mitk::PlaneGeometry::New();
   width  = 100;    widthInMM  = width;
   height = 200;    heightInMM = height;
   mitk::ScalarType bounds[6] = {0, width, 0, height, 0, 1};
   mitk::FillVector3D(origin, 4.5,              7.3, 11.2);
   mitk::FillVector3D(right,  widthInMM,          0, 0);
   mitk::FillVector3D(bottom,         0, heightInMM, 0);
   xyPlane->InitializeStandardPlane(right, bottom);
   xyPlane->SetOrigin(origin);
   xyPlane->SetSizeInUnits(width, height);
 
   std::cout << "Creating VtkAbstractTransformPlaneGeometry: " <<std::endl;
   mitk::VtkAbstractTransformPlaneGeometry::Pointer abstractgeometry=mitk::VtkAbstractTransformPlaneGeometry::New();
 
   std::cout << "Setting xyPlane as parameter plane of VtkAbstractTransformPlaneGeometry: "<<std::endl;
   abstractgeometry->SetPlane(xyPlane);
 
   std::cout << "Testing whether the bounds of xyPlane and the parametric bounds of VtkAbstractTransformPlaneGeometry are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(xyPlane->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(xyPlane->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing whether the parametic bounds of VtkAbstractTransformPlaneGeometry and the bounds of the plane accessed from there are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Change parametic bounds of VtkAbstractTransformPlaneGeometry and test whether they are equal to the bounds of the plane accessed from there: "<<std::endl;
   height = 300;
   bounds[3] = height;
   abstractgeometry->SetParametricBounds(bounds);
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
 
   std::cout << "Initializing an phi-/theta-plane (sphereParameterPlane) as parameter plane by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
   mitk::PlaneGeometry::Pointer sphereParameterPlane = mitk::PlaneGeometry::New();
   width  = 100;    widthInMM  = 2*vnl_math::pi;
   height = 200;    heightInMM =   vnl_math::pi;
   mitk::ScalarType radiusInMM = 2.5;
 
   mitk::FillVector3D(origin, radiusInMM,          0,  widthInMM);
   mitk::FillVector3D(right,  0,                   0, -widthInMM);
   mitk::FillVector3D(bottom, 0,          heightInMM,          0);
   sphereParameterPlane->InitializeStandardPlane(right, bottom);
   sphereParameterPlane->SetOrigin(origin);
   sphereParameterPlane->SetSizeInUnits(width, height);
 
   std::cout << "Creating an vtkSphericalTransform (sphericalTransform) to use with sphereParameterPlane: "<<std::endl;
   vtkSphericalTransform* sphericalTransform = vtkSphericalTransform::New();
 
   std::cout << "Setting sphereParameterPlane as parameter plane and sphericalTransform as transform of VtkAbstractTransformPlaneGeometry: "<<std::endl;
   abstractgeometry->SetPlane(sphereParameterPlane);
   abstractgeometry->SetVtkAbstractTransform(sphericalTransform);
 
   std::cout << "Testing whether the bounds of sphereParameterPlane and the parametric bounds of VtkAbstractTransformPlaneGeometry are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(sphereParameterPlane->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(sphereParameterPlane->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing whether the parametic bounds of VtkAbstractTransformPlaneGeometry and the bounds of the plane accessed from there are equal: ";
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==false))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mapping Map(pt2d_mm(phi=Pi,theta=Pi/2.0), pt3d_mm) and compare with expected (-radius, 0, 0): ";
   mitk::Point2D pt2d_mm;
   mitk::Point3D pt3d_mm, expected_pt3d_mm;
   pt2d_mm[0] = vnl_math::pi; pt2d_mm[1] = vnl_math::pi_over_2;
   mitk::FillVector3D(expected_pt3d_mm, -radiusInMM, 0, 0);
   abstractgeometry->Map(pt2d_mm, pt3d_mm);
   if(mitk::Equal(pt3d_mm, expected_pt3d_mm) == 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;
   abstractgeometry->Map(pt3d_mm, testpt2d_mm);
   if(mitk::Equal(pt2d_mm, testpt2d_mm) == 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;
   abstractgeometry->IndexToWorld(pt2d_units, testpt2d_mm);
   if(mitk::Equal(pt2d_mm, testpt2d_mm) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Change parametic bounds of VtkAbstractTransformPlaneGeometry and test whether they are equal to the bounds of the plane accessed from there: "<<std::endl;
   height = 300;
   bounds[3] = height;
   abstractgeometry->SetParametricBounds(bounds);
   if((mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMinimum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMinimum())==false) ||
      (mitk::Equal(const_cast<mitk::BoundingBox*>(abstractgeometry->GetParametricBoundingBox())->GetMaximum(), const_cast<mitk::BoundingBox*>(abstractgeometry->GetPlane()->GetBoundingBox())->GetMaximum())==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: ";
   pt2d_units[0] = width/2.0;     pt2d_units[1] = height/2.0;
   pt2d_mm[0]    = widthInMM/2.0; pt2d_mm[1]    = heightInMM/2.0;
   abstractgeometry->IndexToWorld(pt2d_units, testpt2d_mm);
   if(mitk::Equal(pt2d_mm, testpt2d_mm) == false)
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
 
   //std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the SlicedGeometry3D: ";
   //mitk::PlaneGeometry* accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(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: "<<std::endl;
   //if((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0))==false) ||
   //   (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
   //   (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false))
   //{
   //  std::cout<<"[FAILED]"<<std::endl;
   //  return EXIT_FAILURE;
   //}
   //std::cout<<"[PASSED]"<<std::endl;
 
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
diff --git a/Core/Code/Testing/mitkBaseDataTest.cpp b/Core/Code/Testing/mitkBaseDataTest.cpp
index 7f4fb8b044..ca397a04d2 100644
--- a/Core/Code/Testing/mitkBaseDataTest.cpp
+++ b/Core/Code/Testing/mitkBaseDataTest.cpp
@@ -1,118 +1,120 @@
 /*===================================================================
 
 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 "mitkBaseDataTestImplementation.h"
 #include "mitkStringProperty.h"
 #include "mitkTestingMacros.h"
+#include <mitkTimeGeometry.h>
+#include <mitkProportionalTimeGeometry.h>
 #include "itkImage.h"
 
-
 int mitkBaseDataTest(int /*argc*/, char* /*argv*/[])
 {
 
   MITK_TEST_BEGIN("BaseData")
 
   //Create a BaseData implementation
   MITK_INFO << "Creating a base data instance...";
   mitk::BaseDataTestImplementation::Pointer baseDataImpl = mitk::BaseDataTestImplementation::New();
 
   MITK_TEST_CONDITION_REQUIRED(baseDataImpl.IsNotNull(),"Testing instantiation");
   MITK_TEST_CONDITION(baseDataImpl->IsInitialized(), "BaseDataTestImplementation is initialized");
   MITK_TEST_CONDITION(baseDataImpl->IsEmpty(), "BaseDataTestImplementation is initialized and empty");
 
+
   mitk::BaseDataTestImplementation::Pointer cloneBaseData = baseDataImpl->Clone();
   MITK_TEST_CONDITION_REQUIRED(cloneBaseData.IsNotNull(),"Testing instantiation of base data clone");
   MITK_TEST_CONDITION(cloneBaseData->IsInitialized(), "Clone of BaseDataTestImplementation is initialized");
   MITK_TEST_CONDITION(cloneBaseData->IsEmpty(), "Clone of BaseDataTestImplementation is initialized and empty");
 
   MITK_INFO << "Testing setter and getter for geometries...";
 
-  //test method GetTimeSlicedGeometry()
-  MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry(), "Testing creation of TimeSlicedGeometry");
+  //test method GetTimeGeometry()
+  MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry(), "Testing creation of TimeGeometry");
 
-  mitk::TimeSlicedGeometry* geo = NULL;
-  baseDataImpl->SetGeometry(geo);
+  mitk::TimeGeometry* geo = NULL;
+  baseDataImpl->SetTimeGeometry(geo);
 
-  MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry() == NULL, "Reset Geometry");
+  MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry() == NULL, "Reset Geometry");
 
-  mitk::TimeSlicedGeometry::Pointer geo2 = mitk::TimeSlicedGeometry::New();
-  baseDataImpl->SetGeometry(geo2);
-  baseDataImpl->InitializeTimeSlicedGeometry(2);
-  MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry() == geo2, "Correct Reinit of TimeslicedGeometry");
+  mitk::ProportionalTimeGeometry::Pointer geo2 = mitk::ProportionalTimeGeometry::New();
+  baseDataImpl->SetTimeGeometry(geo2);
+  geo2->Initialize(2);
+  MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry() == geo2.GetPointer(), "Correct Reinit of TimeGeometry");
 
   //test method GetGeometry(int timeStep)
   MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1) != NULL, "... and single Geometries");
 
   //test method Expand(unsigned int timeSteps)
   baseDataImpl->Expand(5);
   MITK_TEST_CONDITION(baseDataImpl->GetTimeSteps() == 5, "Expand the geometry to further time slices!");
 
   //test method GetUpdatedGeometry(int timeStep);
   mitk::Geometry3D::Pointer geo3 = mitk::Geometry3D::New();
-  mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry = baseDataImpl->GetTimeSlicedGeometry();
-  if (timeSlicedGeometry.IsNotNull() )
+  mitk::ProportionalTimeGeometry::Pointer timeGeometry = dynamic_cast<mitk::ProportionalTimeGeometry *>(baseDataImpl->GetTimeGeometry());
+  if (timeGeometry.IsNotNull() )
   {
-    timeSlicedGeometry->SetGeometry3D(geo3, 1);
+    timeGeometry->SetTimeStepGeometry(geo3,1);
   }
 
   MITK_TEST_CONDITION(baseDataImpl->GetUpdatedGeometry(1) == geo3, "Set Geometry for time step 1");
   MITK_TEST_CONDITION(baseDataImpl->GetMTime()!= 0, "Check if modified time is set");
   baseDataImpl->SetClonedGeometry(geo3, 1);
 
   float x[3];
   x[0] = 2;
   x[1] = 4;
   x[2] = 6;
   mitk::Point3D p3d(x);
   baseDataImpl->SetOrigin(p3d);
   geo3->SetOrigin(p3d);
 
   MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing Origin set");
 
   cloneBaseData = baseDataImpl->Clone();
   MITK_TEST_CONDITION(cloneBaseData->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing origin set in clone!");
 
   MITK_TEST_CONDITION(!baseDataImpl->IsEmptyTimeStep(1), "Is not empty before clear()!");
   baseDataImpl->Clear();
   MITK_TEST_CONDITION(baseDataImpl->IsEmptyTimeStep(1), "...but afterwards!");
   //test method Set-/GetProperty()
   baseDataImpl->SetProperty("property38", mitk::StringProperty::New("testproperty"));
   //baseDataImpl->SetProperty("visibility", mitk::BoolProperty::New());
   MITK_TEST_CONDITION(baseDataImpl->GetProperty("property38")->GetValueAsString() == "testproperty","Check if base property is set correctly!");
 
   cloneBaseData = baseDataImpl->Clone();
   MITK_TEST_CONDITION(cloneBaseData->GetProperty("property38")->GetValueAsString() == "testproperty", "Testing origin set in clone!");
 
   //test method Set-/GetPropertyList
   mitk::PropertyList::Pointer propertyList = mitk::PropertyList::New();
   propertyList->SetFloatProperty("floatProperty1", 123.45);
   propertyList->SetBoolProperty("visibility",true);
   propertyList->SetStringProperty("nameXY","propertyName");
   baseDataImpl->SetPropertyList(propertyList);
   bool value = false;
   MITK_TEST_CONDITION(baseDataImpl->GetPropertyList() == propertyList, "Check if base property list is set correctly!");
   MITK_TEST_CONDITION(baseDataImpl->GetPropertyList()->GetBoolProperty("visibility", value) == true, "Check if base property is set correctly in the property list!");
 
   //test method UpdateOutputInformation()
-   baseDataImpl->UpdateOutputInformation();
-  MITK_TEST_CONDITION(baseDataImpl->GetUpdatedTimeSlicedGeometry() == geo2, "TimeSlicedGeometry update!");
+  baseDataImpl->UpdateOutputInformation();
+  MITK_TEST_CONDITION(baseDataImpl->GetUpdatedTimeGeometry() == geo2, "TimeGeometry update!");
   //Test method CopyInformation()
   mitk::BaseDataTestImplementation::Pointer newBaseData =  mitk::BaseDataTestImplementation::New();
   newBaseData->CopyInformation(baseDataImpl);
-  MITK_TEST_CONDITION_REQUIRED(  newBaseData->GetTimeSlicedGeometry()->GetTimeSteps() == 5, "Check copying of of Basedata Data Object!");
+  MITK_TEST_CONDITION_REQUIRED(  newBaseData->GetTimeGeometry()->GetNumberOfTimeSteps() == 5, "Check copying of of Basedata Data Object!");
 
   MITK_TEST_END()
 }
diff --git a/Core/Code/Testing/mitkDataStorageTest.cpp b/Core/Code/Testing/mitkDataStorageTest.cpp
index c3b9e9a14f..88700caa0c 100644
--- a/Core/Code/Testing/mitkDataStorageTest.cpp
+++ b/Core/Code/Testing/mitkDataStorageTest.cpp
@@ -1,875 +1,875 @@
 /*===================================================================
 
 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 <fstream>
 #include <algorithm>
 
 #include "mitkImage.h"
 #include "mitkSurface.h"
 #include "mitkStringProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkGroupTagProperty.h"
 #include "mitkDataNode.h"
 #include "mitkReferenceCountWatcher.h"
 
 #include "mitkDataStorage.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateDimension.h"
 #include "mitkNodePredicateData.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkNodePredicateSource.h"
 #include "mitkMessage.h"
 //#include "mitkPicFileReader.h"
 #include "mitkTestingMacros.h"
 
 #include "mitkItkImageFileReader.h"
 
 
 void TestDataStorage(mitk::DataStorage* ds, std::string filename);
 
 namespace mitk
 {
   class TestStandaloneDataStorage: public StandaloneDataStorage
   {
   public:
     mitkClassMacro(TestStandaloneDataStorage, mitk::DataStorage);
     itkNewMacro(Self);
     std::map<const mitk::DataNode*, unsigned long>
         GetModifiedObserverTags() const {return m_NodeModifiedObserverTags;}
     std::map<const mitk::DataNode*, unsigned long>
         GetDeletedObserverTags() const { return m_NodeDeleteObserverTags; }
   protected:
     TestStandaloneDataStorage() {}
   };
 }
 
 class DSEventReceiver // Helper class for event testing
 {
 public:
   const mitk::DataNode* m_NodeAdded;
   const mitk::DataNode* m_NodeRemoved;
 
   DSEventReceiver()
     : m_NodeAdded(NULL), m_NodeRemoved(NULL)
   {
   }
 
   void OnAdd(const mitk::DataNode* node)
   {
     m_NodeAdded = node;
   }
 
   void OnRemove(const mitk::DataNode* node)
   {
     m_NodeRemoved = node;
   }
 };
 
 ///
 /// \brief a class for checking if the datastorage is really thread safe
 ///
 /// Therefore it listens to a node contained in the datastorage. when this node
 /// gets removed and deleted, this class gets informed by calling OnObjectDelete().
 /// in OnObjectDelete() an empty node gets added. this must not cause a deadlock
 ///
 struct ItkDeleteEventListener
 {
   ItkDeleteEventListener( mitk::DataStorage* ds )
   :   m_Node(0), m_DataStorage(ds),
   m_DeleteObserverTag(0)
   {
   }
 
   void SetNode( mitk::DataNode* _Node )
   {
     if(m_Node)
       return;
 
     m_Node = _Node;
     itk::MemberCommand<ItkDeleteEventListener>::Pointer onObjectDelete =
       itk::MemberCommand<ItkDeleteEventListener>::New();
 
     onObjectDelete->SetCallbackFunction(this, &ItkDeleteEventListener::OnObjectDelete);
     m_DeleteObserverTag = m_Node->AddObserver(itk::DeleteEvent(), onObjectDelete);
   }
 
   void OnObjectDelete( const itk::Object* /*caller*/, const itk::EventObject & )
   {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     m_DataStorage->Add( node ); // SHOULD NOT CAUSE A DEADLOCK!
     m_DataStorage->Remove( node ); // tidy up: remove the empty node again
 
     m_Node = 0;
   }
 
   protected:
     mitk::DataNode* m_Node;
     mitk::DataStorage::Pointer m_DataStorage;
     unsigned int m_DeleteObserverTag;
 };
 
 //## Documentation
 //## main testing method
 //## NOTE: the current Singleton implementation of DataTreeStorage will lead to crashes if a testcase fails
 //##       and therefore mitk::DataStorage::ShutdownSingleton() is not called.
 int mitkDataStorageTest(int argc, char* argv[])
 {
   MITK_TEST_BEGIN("DataStorageTest");
 
   // muellerm: test observer tag remove
   mitk::TestStandaloneDataStorage::Pointer testDS
       = mitk::TestStandaloneDataStorage::New();
   mitk::DataNode::Pointer n1 = mitk::DataNode::New();
   testDS->Add(n1);
   MITK_TEST_CONDITION_REQUIRED(
       testDS->GetModifiedObserverTags().size()==1, "Testing if modified"
       " observer was added.");
   MITK_TEST_CONDITION_REQUIRED(
       testDS->GetDeletedObserverTags().size()==1, "Testing if delete"
       " observer was added.");
   testDS->Remove(n1);
   MITK_TEST_CONDITION_REQUIRED(
       testDS->GetModifiedObserverTags().size()==0, "Testing if modified"
       " observer was removed.");
   MITK_TEST_CONDITION_REQUIRED(
       testDS->GetDeletedObserverTags().size()==0, "Testing if delete"
       " observer was removed.");
 
   /* Create StandaloneDataStorage */
   MITK_TEST_OUTPUT( << "Create StandaloneDataStorage : ");
   mitk::StandaloneDataStorage::Pointer sds;
   try
   {
     sds = mitk::StandaloneDataStorage::New();
     MITK_TEST_CONDITION_REQUIRED(sds.IsNotNull(), "Testing Instatiation");
   }
   catch (...)
   {
     MITK_TEST_FAILED_MSG( << "Exception during creation of StandaloneDataStorage");
   }
 
   MITK_TEST_OUTPUT( << "Testing StandaloneDataStorage: ");
   MITK_TEST_CONDITION_REQUIRED(argc>1, "Testing correct test invocation");
   TestDataStorage(sds,argv[1]);
   // TODO: Add specific StandaloneDataStorage Tests here
   sds = NULL;
 
   MITK_TEST_END();
 }
 
 //##Documentation
 //## @brief Test for the DataStorage class and its associated classes (e.g. the predicate classes)
 //## This method will be called once for each subclass of DataStorage
 void TestDataStorage( mitk::DataStorage* ds, std::string filename )
 {
   /* DataStorage valid? */
   MITK_TEST_CONDITION_REQUIRED(ds != NULL, "DataStorage valid?");
 
   // Take the ItkImageFile Reader for the .nrrd data format.
   // (was previously pic which is now deprecated format)
   mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
   reader -> SetFileName(filename.c_str());
   reader -> Update();
   mitk::Image::Pointer image = reader->GetOutput();
 
   // create some DataNodes to fill the ds
   mitk::DataNode::Pointer n1 = mitk::DataNode::New();   // node with image and name property
 //  mitk::Image::Pointer image = mitk::Image::New();
 //  unsigned int imageDimensions[] = { 10, 10, 10, 10 };
 //  mitk::PixelType pt(typeid(int));
 //  image->Initialize( pt, 4, imageDimensions );
   n1->SetData(image);
   n1->SetProperty("name", mitk::StringProperty::New("Node 1 - Image Node"));
   mitk::DataStorage::SetOfObjects::Pointer parents1 = mitk::DataStorage::SetOfObjects::New();
 
   mitk::DataNode::Pointer n2 = mitk::DataNode::New();   // node with surface and name and color properties
   mitk::Surface::Pointer surface = mitk::Surface::New();
   n2->SetData(surface);
   n2->SetProperty("name", mitk::StringProperty::New("Node 2 - Surface Node"));
   mitk::Color color;  color.Set(1.0f, 1.0f, 0.0f);
   n2->SetColor(color);
   n2->SetProperty("Resection Proposal 1", mitk::GroupTagProperty::New());
   mitk::DataStorage::SetOfObjects::Pointer parents2 = mitk::DataStorage::SetOfObjects::New();
   parents2->InsertElement(0, n1);  // n1 (image node) is source of n2 (surface node)
 
   mitk::DataNode::Pointer n3 = mitk::DataNode::New();   // node without data but with name property
   n3->SetProperty("name", mitk::StringProperty::New("Node 3 - Empty Node"));
   n3->SetProperty("Resection Proposal 1", mitk::GroupTagProperty::New());
   n3->SetProperty("Resection Proposal 2", mitk::GroupTagProperty::New());
   mitk::DataStorage::SetOfObjects::Pointer parents3 = mitk::DataStorage::SetOfObjects::New();
   parents3->InsertElement(0, n2);  // n2 is source of n3
 
   mitk::DataNode::Pointer n4 = mitk::DataNode::New();   // node without data but with color property
   n4->SetColor(color);
   n4->SetProperty("Resection Proposal 2", mitk::GroupTagProperty::New());
   mitk::DataStorage::SetOfObjects::Pointer parents4 = mitk::DataStorage::SetOfObjects::New();
   parents4->InsertElement(0, n2);
   parents4->InsertElement(1, n3);  // n2 and n3 are sources of n4
 
   mitk::DataNode::Pointer n5 = mitk::DataNode::New();   // extra node
   n5->SetProperty("name", mitk::StringProperty::New("Node 5"));
 
   try /* adding objects */
   {
     /* Add an object */
     ds->Add(n1, parents1);
     MITK_TEST_CONDITION_REQUIRED((ds->GetAll()->Size() == 1) && (ds->GetAll()->GetElement(0) == n1), "Testing Adding a new object");
 
     /* Check exception on adding the same object again */
     MITK_TEST_OUTPUT( << "Check exception on adding the same object again: ");
     MITK_TEST_FOR_EXCEPTION(..., ds->Add(n1, parents1));
     MITK_TEST_CONDITION(ds->GetAll()->Size() == 1, "Test if object count is correct after exception");
 
     /* Add an object that has a source object */
     ds->Add(n2, parents2);
     MITK_TEST_CONDITION_REQUIRED(ds->GetAll()->Size() == 2, "Testing Adding an object that has a source object");
 
     /* Add some more objects needed for further tests */
     ds->Add(n3, parents3);   // n3 object that has name property and one parent
     ds->Add(n4, parents4);   // n4 object that has color property
     ds->Add(n5);             // n5 has no parents
     MITK_TEST_CONDITION_REQUIRED(ds->GetAll()->Size() == 5, "Adding some more objects needed for further tests");
   }
   catch(...)
   {
     MITK_TEST_FAILED_MSG( << "Exeption during object creation");
   }
 
   try  /* object retrieval methods */
   {
     /* Requesting all Objects */
     {
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetAll();
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
 
       MITK_TEST_CONDITION(
         (stlAll.size() == 5)  // check if all tree nodes are in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end()) && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) && (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n5) != stlAll.end()),
         "Testing GetAll()"
         );
     }
     /* Requesting a named object */
     {
       mitk::NodePredicateProperty::Pointer predicate(mitk::NodePredicateProperty::New("name", mitk::StringProperty::New("Node 2 - Surface Node")));
       mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n2), "Requesting a named object");
     }
 
     /* Requesting objects of specific data type */
     {
       mitk::NodePredicateDataType::Pointer predicate(mitk::NodePredicateDataType::New("Image"));
       mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n1), "Requesting objects of specific data type")
     }
     /* Requesting objects of specific dimension */
     {
       mitk::NodePredicateDimension::Pointer predicate(mitk::NodePredicateDimension::New( 4 ));
       mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n1), "Requesting objects of specific dimension")
     }
     /* Requesting objects with specific data object */
     {
       mitk::NodePredicateData::Pointer predicate(mitk::NodePredicateData::New(image));
       mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n1), "Requesting objects with specific data object")
     }
     /* Requesting objects with NULL data */
     {
       mitk::NodePredicateData::Pointer predicate(mitk::NodePredicateData::New(NULL));
       mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       MITK_TEST_CONDITION(
         (all->Size() == 3)
         && (std::find(all->begin(), all->end(), n3) != all->end())
         && (std::find(all->begin(), all->end(), n4) != all->end())
         && (std::find(all->begin(), all->end(), n5) != all->end())
         , "Requesting objects with NULL data");
     }
     /* Requesting objects that meet a conjunction criteria */
     {
       mitk::NodePredicateDataType::Pointer p1 = mitk::NodePredicateDataType::New("Surface");
       mitk::NodePredicateProperty::Pointer p2 = mitk::NodePredicateProperty::New("color", mitk::ColorProperty::New(color));
       mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New();
       predicate->AddPredicate(p1);
       predicate->AddPredicate(p2);  // objects must be of datatype "Surface" and have red color (= n2)
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n2), "Requesting objects that meet a conjunction criteria");
     }
     /* Requesting objects that meet a disjunction criteria */
     {
       mitk::NodePredicateDataType::Pointer p1(mitk::NodePredicateDataType::New("Image"));
       mitk::NodePredicateProperty::Pointer p2(mitk::NodePredicateProperty::New("color", mitk::ColorProperty::New(color)));
       mitk::NodePredicateOr::Pointer predicate = mitk::NodePredicateOr::New();
       predicate->AddPredicate(p1);
       predicate->AddPredicate(p2);  // objects must be of datatype "Surface" or have red color (= n1, n2, n4)
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       MITK_TEST_CONDITION(
         (all->Size() == 3)
         && (std::find(all->begin(), all->end(), n1) != all->end())
         && (std::find(all->begin(), all->end(), n2) != all->end())
         && (std::find(all->begin(), all->end(), n4) != all->end()),
         "Requesting objects that meet a disjunction criteria");
     }
     /* Requesting objects that do not meet a criteria */
     {
       mitk::ColorProperty::Pointer cp = mitk::ColorProperty::New(color);
       mitk::NodePredicateProperty::Pointer proppred(mitk::NodePredicateProperty::New("color", cp));
       mitk::NodePredicateNot::Pointer predicate(mitk::NodePredicateNot::New(proppred));
 
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 3) // check if correct objects are in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n5) != stlAll.end()), "Requesting objects that do not meet a criteria");
     }
 
     /* Requesting *direct* source objects */
     {
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n3, NULL, true); // Get direct parents of n3 (=n2)
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 1) && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end()),
         "Requesting *direct* source objects");
     }
 
     /* Requesting *all* source objects */
     {
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n3, NULL, false); // Get all parents of n3 (= n1 + n2)
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 2)
         && (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end()),
         "Requesting *all* source objects"); // check if n1 and n2 are the resultset
     }
 
     /* Requesting *all* sources of object with multiple parents */
     {
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, NULL, false); // Get all parents of n4 (= n1 + n2 + n3)
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 3)
         && (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) // check if n1 and n2 and n3 are the resultset
         , "Requesting *all* sources of object with multiple parents");
     }
 
     /* Requesting *direct* derived objects */
     {
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, NULL, true); // Get direct childs of n1 (=n2)
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 1)
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())// check if n1 is the resultset
         , "Requesting *direct* derived objects");
 
     }
 
     ///* Requesting *direct* derived objects with multiple parents/derivations */
 
     {
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n2, NULL, true); // Get direct childs of n2 (=n3 + n4)
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 2)
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) // check if n3 is the resultset
         && (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end()) // check if n4 is the resultset
         , "Requesting *direct* derived objects with multiple parents/derivations");
     }
 
     //* Requesting *all* derived objects */
     {
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, NULL, false); // Get all childs of n1 (=n2, n3, n4)
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 3)
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
         , "Requesting *all* derived objects");
     }
 
     /* Checking for circular source relationships */
     {
       parents1->InsertElement(0, n4);   // make n1 derived from n4 (which is derived from n2, which is derived from n1)
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, NULL, false); // Get all parents of n4 (= n1 + n2 + n3, not n4 itself and not multiple versions of the nodes!)
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 3)
         && (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) // check if n1 and n2 and n3 are the resultset
         , "Checking for circular source relationships");
     }
 
     ///* Checking for circular derivation relationships can not be performed, because the internal derivations datastructure
     //   can not be accessed from the outside. (Therefore it should not be possible to create these circular relations */
 
     //* Checking GroupTagProperty */
     {
       mitk::GroupTagProperty::Pointer tp = mitk::GroupTagProperty::New();
       mitk::NodePredicateProperty::Pointer pred(mitk::NodePredicateProperty::New("Resection Proposal 1", tp));
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(pred);
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 2) // check if n2 and n3 are in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
         , "Checking GroupTagProperty");
     }
 
     /* Checking GroupTagProperty 2 */
     {
       mitk::GroupTagProperty::Pointer tp = mitk::GroupTagProperty::New();
       mitk::NodePredicateProperty::Pointer pred(mitk::NodePredicateProperty::New("Resection Proposal 2", tp));
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(pred);
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 2) // check if n3 and n4 are in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
         , "Checking GroupTagProperty 2");
 
     }
 
     /* Checking direct sources with condition */
     {
       mitk::NodePredicateDataType::Pointer pred = mitk::NodePredicateDataType::New("Surface");
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, pred, true);
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 1) // check if n2 is in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         , "checking direct sources with condition");
     }
 
     /* Checking all sources with condition */
     {
       mitk::NodePredicateDataType::Pointer pred = mitk::NodePredicateDataType::New("Image");
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, pred, false);
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 1) // check if n1 is in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
         , "Checking all sources with condition");
     }
 
     /* Checking all sources with condition with empty resultset */
     {
       mitk::NodePredicateDataType::Pointer pred = mitk::NodePredicateDataType::New("VesselTree");
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, pred, false);
       MITK_TEST_CONDITION(all->Size() == 0 , "Checking all sources with condition with empty resultset"); // check if resultset is empty
     }
 
     /* Checking direct derivations with condition */
     {
       mitk::NodePredicateProperty::Pointer pred = mitk::NodePredicateProperty::New("color");
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, pred, true);
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 1) // check if n2 is in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         , "Checking direct derivations with condition");
     }
 
     /* Checking all derivations with condition */
     {
       mitk::NodePredicateProperty::Pointer pred = mitk::NodePredicateProperty::New("color");
 
       const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, pred, false);
       std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
       MITK_TEST_CONDITION(
         (all->Size() == 2) // check if n2 and n4 are in resultset
         && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
         && (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
         , "Checking direct derivations with condition");
     }
 
     /* Checking named node method */
     MITK_TEST_CONDITION(ds->GetNamedNode("Node 2 - Surface Node") == n2, "Checking named node method");
     MITK_TEST_CONDITION(ds->GetNamedNode(std::string("Node 2 - Surface Node")) == n2, "Checking named node(std::string) method");
 
     /* Checking named node method with wrong name */
     MITK_TEST_CONDITION(ds->GetNamedNode("This name does not exist") == NULL, "Checking named node method with wrong name");
 
     /* Checking named object method */
     MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Image>("Node 1 - Image Node") == image, "Checking named object method");
     MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Image>(std::string("Node 1 - Image Node")) == image, "Checking named object(std::string) method");
 
     /* Checking named object method with wrong DataType */
     MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Surface>("Node 1 - Image Node") == NULL, "Checking named object method with wrong DataType");
 
     /* Checking named object method with wrong name */
     MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Image>("This name does not exist") == NULL, "Checking named object method with wrong name");
 
     /* Checking GetNamedDerivedNode with valid name and direct derivation only */
     MITK_TEST_CONDITION(ds->GetNamedDerivedNode("Node 2 - Surface Node", n1, true) == n2, "Checking GetNamedDerivedNode with valid name & direct derivation only");
 
     /* Checking GetNamedDerivedNode with invalid Name and direct derivation only */
     MITK_TEST_CONDITION(ds->GetNamedDerivedNode("wrong name", n1, true) == NULL, "Checking GetNamedDerivedNode with invalid name & direct derivation only");
 
     /* Checking GetNamedDerivedNode with invalid Name and direct derivation only */
     MITK_TEST_CONDITION(ds->GetNamedDerivedNode("Node 3 - Empty Node", n1, false) == n3, "Checking GetNamedDerivedNode with invalid name & direct derivation only");
 
 
     /* Checking GetNamedDerivedNode with valid Name but direct derivation only */
     MITK_TEST_CONDITION(ds->GetNamedDerivedNode("Node 3 - Empty Node", n1, true) == NULL, "Checking GetNamedDerivedNode with valid Name but direct derivation only");
 
     /* Checking GetNode with valid predicate */
     {
       mitk::NodePredicateDataType::Pointer p(mitk::NodePredicateDataType::New("Image"));
       MITK_TEST_CONDITION(ds->GetNode(p) == n1, "Checking GetNode with valid predicate");
     }
     /* Checking GetNode with invalid predicate */
     {
       mitk::NodePredicateDataType::Pointer p(mitk::NodePredicateDataType::New("PointSet"));
       MITK_TEST_CONDITION(ds->GetNode(p) == NULL, "Checking GetNode with invalid predicate");
     }
 
   } // object retrieval methods
   catch(...)
   {
     MITK_TEST_FAILED_MSG( << "Exeption during object retrieval (GetXXX() Methods)");
   }
 
   try  /* object removal methods */
   {
 
     /* Checking removal of a node without relations */
     {
       mitk::DataNode::Pointer extra = mitk::DataNode::New();
       extra->SetProperty("name", mitk::StringProperty::New("extra"));
       mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
       int refCountbeforeDS = watcher->GetReferenceCount();
       ds->Add(extra);
       MITK_TEST_CONDITION(ds->GetNamedNode("extra") == extra, "Adding extra node");
       ds->Remove(extra);
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == NULL)
         && (refCountbeforeDS == watcher->GetReferenceCount())
         , "Checking removal of a node without relations");
       extra = NULL;
     }
 
     /* Checking removal of a node with a parent */
     {
       mitk::DataNode::Pointer extra = mitk::DataNode::New();
       extra->SetProperty("name", mitk::StringProperty::New("extra"));
 
       mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
       int refCountbeforeDS = watcher->GetReferenceCount();
       ds->Add(extra, n1);   // n1 is parent of extra
 
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == extra)
         && (ds->GetDerivations(n1)->Size() == 2)   // n2 and extra should be derived from n1
         , "Adding extra node");
       ds->Remove(extra);
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == NULL)
         && (refCountbeforeDS == watcher->GetReferenceCount())
         && (ds->GetDerivations(n1)->Size() == 1)
         , "Checking removal of a node with a parent");
       extra = NULL;
     }
 
     /* Checking removal of a node with two parents */
     {
       mitk::DataNode::Pointer extra = mitk::DataNode::New();
       extra->SetProperty("name", mitk::StringProperty::New("extra"));
 
       mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
       int refCountbeforeDS = watcher->GetReferenceCount();
       mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
       p->push_back(n1);
       p->push_back(n2);
       ds->Add(extra, p);   // n1 and n2 are parents of extra
 
 
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == extra)
         && (ds->GetDerivations(n1)->Size() == 2)    // n2 and extra should be derived from n1
         && (ds->GetDerivations(n2)->Size() == 3)
         , "add extra node");
 
       ds->Remove(extra);
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == NULL)
         && (refCountbeforeDS == watcher->GetReferenceCount())
         && (ds->GetDerivations(n1)->Size() == 1)   // after remove, only n2 should be derived from n1
         && (ds->GetDerivations(n2)->Size() == 2)   // after remove, only n3 and n4 should be derived from n2
         , "Checking removal of a node with two parents");
       extra = NULL;
     }
 
     /* Checking removal of a node with two derived nodes */
     {
       mitk::DataNode::Pointer extra = mitk::DataNode::New();
       extra->SetProperty("name", mitk::StringProperty::New("extra"));
       mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
       int refCountbeforeDS = watcher->GetReferenceCount();
       ds->Add(extra);
       mitk::DataNode::Pointer d1 = mitk::DataNode::New();
       d1->SetProperty("name", mitk::StringProperty::New("d1"));
       ds->Add(d1, extra);
       mitk::DataNode::Pointer d2 = mitk::DataNode::New();
       d2->SetProperty("name", mitk::StringProperty::New("d2"));
       ds->Add(d2, extra);
 
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == extra)
         && (ds->GetNamedNode("d1") == d1)
         && (ds->GetNamedNode("d2") == d2)
         && (ds->GetSources(d1)->Size() == 1)    // extra should be source of d1
         && (ds->GetSources(d2)->Size() == 1)    // extra should be source of d2
         && (ds->GetDerivations(extra)->Size() == 2)    // d1 and d2 should be derived from extra
         , "add extra node");
 
       ds->Remove(extra);
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == NULL)
         && (ds->GetNamedNode("d1") == d1)
         && (ds->GetNamedNode("d2") == d2)
         && (refCountbeforeDS == watcher->GetReferenceCount())
         && (ds->GetSources(d1)->Size() == 0)   // after remove, d1 should not have a source anymore
         && (ds->GetSources(d2)->Size() == 0)   // after remove, d2 should not have a source anymore
         , "Checking removal of a node with two derived nodes");
       extra = NULL;
     }
 
     /* Checking removal of a node with two parents and two derived nodes */
     {
       mitk::DataNode::Pointer extra = mitk::DataNode::New();
       extra->SetProperty("name", mitk::StringProperty::New("extra"));
       mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
       mitk::ReferenceCountWatcher::Pointer n1watcher = new mitk::ReferenceCountWatcher(n1);
       int refCountbeforeDS = watcher->GetReferenceCount();
 
       mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
       p->push_back(n1);
       p->push_back(n2);
       ds->Add(extra, p);   // n1 and n2 are parents of extra
 
       mitk::DataNode::Pointer d1 = mitk::DataNode::New();
       d1->SetProperty("name", mitk::StringProperty::New("d1x"));
       ds->Add(d1, extra);
       mitk::DataNode::Pointer d2 = mitk::DataNode::New();
       d2->SetProperty("name", mitk::StringProperty::New("d2x"));
       ds->Add(d2, extra);
 
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == extra)
         && (ds->GetNamedNode("d1x") == d1)
         && (ds->GetNamedNode("d2x") == d2)
         && (ds->GetSources(d1)->Size() == 1)    // extra should be source of d1
         && (ds->GetSources(d2)->Size() == 1)    // extra should be source of d2
         && (ds->GetDerivations(n1)->Size() == 2)    // n2 and extra should be derived from n1
         && (ds->GetDerivations(n2)->Size() == 3)   // n3, n4 and extra should be derived from n2
         && (ds->GetDerivations(extra)->Size() == 2)    // d1 and d2 should be derived from extra
         , "add extra node");
 
       ds->Remove(extra);
       MITK_TEST_CONDITION(
         (ds->GetNamedNode("extra") == NULL)
         && (ds->GetNamedNode("d1x") == d1)
         && (ds->GetNamedNode("d2x") == d2)
         && (refCountbeforeDS == watcher->GetReferenceCount())
         && (ds->GetDerivations(n1)->Size() == 1)    // after remove, only n2 should be derived from n1
         && (ds->GetDerivations(n2)->Size() == 2)    // after remove, only n3 and n4 should be derived from n2
         && (ds->GetSources(d1)->Size() == 0)        // after remove, d1 should not have a source anymore
         && (ds->GetSources(d2)->Size() == 0)       // after remove, d2 should not have a source anymore
         , "Checking removal of a node with two parents and two derived nodes");
       extra = NULL;
     }
   }
   catch(...)
   {
     MITK_TEST_FAILED_MSG( << "Exeption during object removal methods");
   }
 
 
 
   /* Checking for node is it's own parent exception */
   {
     MITK_TEST_FOR_EXCEPTION_BEGIN(...);
     mitk::DataNode::Pointer extra = mitk::DataNode::New();
     extra->SetProperty("name", mitk::StringProperty::New("extra"));
     mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
     p->push_back(n1);
     p->push_back(extra); // extra is parent of extra!!!
     ds->Add(extra, p);
     MITK_TEST_FOR_EXCEPTION_END(...);
   }
 
 
   /* Checking reference count of node after add and remove */
   {
     mitk::DataNode::Pointer extra = mitk::DataNode::New();
     mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
     extra->SetProperty("name", mitk::StringProperty::New("extra"));
     mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
     p->push_back(n1);
     p->push_back(n3);
     ds->Add(extra, p);
     extra = NULL;
     ds->Remove(ds->GetNamedNode("extra"));
     MITK_TEST_CONDITION(watcher->GetReferenceCount() == 0, "Checking reference count of node after add and remove");
   }
 
   /* Checking removal of a node with two derived nodes [ dataStorage->GetDerivations( rootNode )] see bug #3426 */
   {
     mitk::DataNode::Pointer extra = mitk::DataNode::New();
     extra->SetProperty("name", mitk::StringProperty::New("extra"));
 
     ds->Add(extra);
     mitk::DataNode::Pointer d1y = mitk::DataNode::New();
     d1y->SetProperty("name", mitk::StringProperty::New("d1y"));
     mitk::ReferenceCountWatcher::Pointer watcherD1y = new mitk::ReferenceCountWatcher(d1y);
     int refCountbeforeDS = watcherD1y->GetReferenceCount();
     ds->Add(d1y, extra);
     mitk::DataNode::Pointer d2y = mitk::DataNode::New();
     d2y->SetProperty("name", mitk::StringProperty::New("d2y"));
     ds->Add(d2y, extra);
 
     MITK_TEST_CONDITION(
       (ds->GetNamedNode("extra") == extra)
       && (ds->GetNamedNode("d1y") == d1y)
       && (ds->GetNamedNode("d2y") == d2y)
       && (ds->GetSources(d1y)->Size() == 1)    // extra should be source of d1y
       && (ds->GetSources(d2y)->Size() == 1)    // extra should be source of d2y
       && (ds->GetDerivations(extra)->Size() == 2)    // d1y and d2y should be derived from extra
       , "add extra node");
 
     ds->Remove(ds->GetDerivations( extra));
     MITK_TEST_CONDITION(
       (ds->GetNamedNode("extra") == extra)
       && (ds->GetNamedNode("d1y") == NULL) // d1y should be NULL now
       && (ds->GetNamedNode("d2y") == NULL) // d2y should be NULL now
       && (refCountbeforeDS == watcherD1y->GetReferenceCount())
       , "Checking removal of subset of two derived nodes from one parent node");
 
     ds->Remove(extra);
     MITK_TEST_CONDITION(
       (ds->GetNamedNode("extra") == NULL)
       , "Checking removal of a parent node");
     extra = NULL;
   }
 
   /* Checking GetGrouptags() */
   {
     const std::set<std::string> groupTags = ds->GetGroupTags();
     MITK_TEST_CONDITION(
       (groupTags.size() == 2)
       && (std::find(groupTags.begin(), groupTags.end(), "Resection Proposal 1") != groupTags.end())
       && (std::find(groupTags.begin(), groupTags.end(), "Resection Proposal 2") != groupTags.end())
       , "Checking GetGrouptags()");
   }
 
 
   /* Checking Event handling */
   DSEventReceiver listener;
   try
   {
     ds->AddNodeEvent += mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnAdd);
     ds->RemoveNodeEvent += mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnRemove);
 
     mitk::DataNode::Pointer extra = mitk::DataNode::New();
     mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
     ds->Add(extra);
 
     MITK_TEST_CONDITION(listener.m_NodeAdded == extra.GetPointer(), "Checking AddEvent");
 
     ds->Remove(extra);
     MITK_TEST_CONDITION(listener.m_NodeRemoved == extra.GetPointer(), "Checking RemoveEvent");
 
     /* RemoveListener */
     ds->AddNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnAdd);
     ds->RemoveNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnRemove);
     listener.m_NodeAdded = NULL;
     listener.m_NodeRemoved = NULL;
     ds->Add(extra);
     ds->Remove(extra);
     MITK_TEST_CONDITION((listener.m_NodeRemoved == NULL) && (listener.m_NodeAdded == NULL), "Checking RemoveListener");
 
 
     std::cout << "Pointer handling after event handling: " << std::flush;
     extra = NULL; // delete reference to the node. its memory should be freed now
     MITK_TEST_CONDITION(watcher->GetReferenceCount() == 0, "Pointer handling after event handling");
   }
   catch(...)
   {
     /* cleanup */
     ds->AddNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnAdd);
     ds->RemoveNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnRemove);
     MITK_TEST_FAILED_MSG( << "Exception during object removal methods");
   }
 
   //Checking ComputeBoundingGeometry3D method*/
   const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetAll();
-  mitk::TimeSlicedGeometry::Pointer geometry = ds->ComputeBoundingGeometry3D();
-  MITK_TEST_CONDITION(geometry->GetTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry()");
+  mitk::TimeGeometry::Pointer geometry = ds->ComputeBoundingGeometry3D();
+  MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry()");
   mitk::TimeBounds timebounds = geometry->GetTimeBounds();
   MITK_TEST_CONDITION((timebounds[0]==0)&&(timebounds[1]==4),"Test for timebounds with ComputeBoundingGeometry()");
-  for (unsigned int i=0; i<geometry->GetTimeSteps(); i++)
+  for (unsigned int i=0; i<geometry->GetNumberOfTimeSteps(); i++)
   {
-    mitk::Geometry3D::Pointer subGeometry = geometry->GetGeometry3D(i);
+    mitk::Geometry3D::Pointer subGeometry = geometry->GetGeometryForTimeStep(i);
     mitk::TimeBounds bounds = subGeometry->GetTimeBounds();
     MITK_TEST_CONDITION((bounds[0]==i)&&(bounds[1]==i+1),"Test for timebounds of geometry at different time steps with ComputeBoundingGeometry()");
   }
   geometry = ds->ComputeBoundingGeometry3D(all);
-  MITK_TEST_CONDITION(geometry->GetTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry(allNodes)");
+  MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry(allNodes)");
   timebounds = geometry->GetTimeBounds();
   MITK_TEST_CONDITION((timebounds[0]==0)&&(timebounds[1]==4),"Test for timebounds with ComputeBoundingGeometry(allNodes)");
-  for (unsigned int i=0; i<geometry->GetTimeSteps(); i++)
+  for (unsigned int i=0; i<geometry->GetNumberOfTimeSteps(); i++)
   {
-    mitk::Geometry3D::Pointer subGeometry = geometry->GetGeometry3D(i);
+    mitk::Geometry3D::Pointer subGeometry = geometry->GetGeometryForTimeStep(i);
     mitk::TimeBounds bounds = subGeometry->GetTimeBounds();
     MITK_TEST_CONDITION((bounds[0]==i)&&(bounds[1]==i+1),"Test for timebounds of geometry at different time steps with ComputeBoundingGeometry()");
   }
 
   // test for thread safety of DataStorage
   try
   {
     mitk::StandaloneDataStorage::Pointer standaloneDataStorage
         = mitk::StandaloneDataStorage::New();
     ItkDeleteEventListener listener( standaloneDataStorage );
     {
       mitk::DataNode::Pointer emptyNode = mitk::DataNode::New();
       mitk::DataNode* pEmptyNode = emptyNode;
       listener.SetNode( emptyNode );
       standaloneDataStorage->Add( emptyNode );
       emptyNode = 0; // emptyNode is still alive because standaloneDataStorage
                      // owns it
       standaloneDataStorage->Remove( pEmptyNode ); // this should not freeze the whole thing
     }
   }
   catch(...)
   {
     MITK_TEST_FAILED_MSG( << "Exception during testing DataStorage thread safe");
   }
 
   /* Clear DataStorage */
   ds->Remove(ds->GetAll());
   MITK_TEST_CONDITION(ds->GetAll()->Size() == 0, "Checking Clear DataStorage");
 }
diff --git a/Core/Code/Testing/mitkImageTest.cpp b/Core/Code/Testing/mitkImageTest.cpp
index e91fada8c4..8bb65e1226 100644
--- a/Core/Code/Testing/mitkImageTest.cpp
+++ b/Core/Code/Testing/mitkImageTest.cpp
@@ -1,499 +1,496 @@
 /*===================================================================
 
 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 "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;
 }
 
 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::Geometry3D::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;
   int *p2;
   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::Geometry3D*>(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(): ");
-  MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetOrigin(), origin), "Testing correctness of origin via GetTimeSlicedGeometry()->GetOrigin(): ");
 
   // Setting origin via SetOrigin(origin): ";
-  mitk::FillVector3D(origin, 37.0, 17.92, 27.83);
-  imgMem->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->GetTimeSlicedGeometry()->GetOrigin(), origin), "Testing correctness of changed origin via GetTimeSlicedGeometry()->GetOrigin(): ");
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(), origin),  "Testing correctness of changed origin via GetSlicedGeometry()->GetGeometry2D(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_TEST_CONDITION_REQUIRED(mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetSpacing(), spacing), "Testing correctspacing from TimeSlicedGeometry!");
 
   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->GetTimeSlicedGeometry()->GetSpacing(), spacing), "Testing correctness of changed spacing via GetTimeSlicedGeometry()->GetSpacing(): ");
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(), spacing), "Testing correctness of changed spacing via GetSlicedGeometry()->GetGeometry2D(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->SetScalarType( VTK_SHORT );
   vtkimage->AllocateScalars();
   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), "");
 
-  MITK_TEST_OUTPUT(<< " Testing whether GetTimeSlicedGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
-  origin2 = mitkByVtkImage->GetTimeSlicedGeometry()->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::Geometry2D& 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();
 
   // 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] << "";
   mitk::Point3D point;
 
   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();
   mitk::ScalarType value = image->GetPixelValueByWorldCoordinate(point);
   MITK_INFO << imageMin << " "<< imageMax << " "<< value << "";
   MITK_TEST_CONDITION( (value >= imageMin && value <= imageMax), "Value returned is between max/min");
 
   // 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();
   const unsigned int timestep = 0;
 
   // 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_TEST_CONDITION_REQUIRED( image->GetPixelValueByWorldCoordinate(position, timestep) == 0, "Test access to the outside of the image")
 
-
+  {
     // 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->GetTimeSlicedGeometry()->GetGeometry3D(cloneImage->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix(),
-    cloneImage->GetTimeSlicedGeometry()->GetGeometry3D(image->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix()), "Clone(testing time sliced geometry)");
+  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<float,3> ItkFloatImage3D;
+    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)
     {
       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/mitkSTLFileReaderTest.cpp b/Core/Code/Testing/mitkSTLFileReaderTest.cpp
index 5cd2feb969..842bc35f98 100644
--- a/Core/Code/Testing/mitkSTLFileReaderTest.cpp
+++ b/Core/Code/Testing/mitkSTLFileReaderTest.cpp
@@ -1,78 +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 "mitkImage.h"
 #include "mitkSTLFileReader.h"
-#include "mitkTimeSlicedGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkSurface.h"
 #include "mitkTestingMacros.h"
 #include <vtkSTLReader.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 #include <fstream>
 int mitkSTLFileReaderTest(int argc, char* argv[])
 {
   // always start with this!
   MITK_TEST_BEGIN("STLFileReader")
 
   //Read STL-Image from file
   mitk::STLFileReader::Pointer reader = mitk::STLFileReader::New();
 
   if(argc==0)
   {
     std::cout<<"file not found - test not applied [PASSED]"<<std::endl;
     std::cout<<"[TEST DONE]"<<std::endl;
     return EXIT_SUCCESS;
   }
 
   std::cout << "Testing CanReadFile(): ";
   if (!reader->CanReadFile(argv[1], "", ""))
   {
     //std::cout<<"[FAILED]"<<std::endl;
     //return EXIT_FAILURE;
     MITK_TEST_OUTPUT(<< mitkTestName << ": "<< mitk::TestManager::GetInstance()->NumberOfPassedTests() << " tests [DONE PASSED] File is not STL!")
     return EXIT_SUCCESS;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   reader->SetFileName(argv[1]);
   reader->Update();
 
   MITK_TEST_CONDITION_REQUIRED((reader->GetOutput() != NULL),"Reader output not NULL")
 
   mitk::Surface::Pointer surface = reader->GetOutput();
   MITK_TEST_CONDITION_REQUIRED(surface->IsInitialized(),"IsInitialized()")
 
   MITK_TEST_CONDITION_REQUIRED((surface->GetVtkPolyData()!=NULL),"mitk::Surface::SetVtkPolyData()")
 
   MITK_TEST_CONDITION_REQUIRED((surface->GetGeometry()!=NULL),"Availability of geometry")
 
   vtkSmartPointer<vtkSTLReader> myVtkSTLReader = vtkSmartPointer<vtkSTLReader>::New();
   myVtkSTLReader->SetFileName( argv[1] );
   myVtkSTLReader->Update();
   vtkSmartPointer<vtkPolyData> myVtkPolyData = myVtkSTLReader->GetOutput();
   // vtkPolyData from vtkSTLReader directly
   int n = myVtkPolyData->GetNumberOfPoints();
   // vtkPolyData from mitkSTLFileReader
   int m = surface->GetVtkPolyData()->GetNumberOfPoints();
   MITK_TEST_CONDITION_REQUIRED((n == m),"Number of Points in VtkPolyData")
 
   // always end with this!
   MITK_TEST_END()
 }
diff --git a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
index 43bfb4e87d..f2157f36a3 100644
--- a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
+++ b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
@@ -1,581 +1,583 @@
 /*===================================================================
 
 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 "mitkTimeSlicedGeometry.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::Geometry3D & geometry,
+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::Geometry3D::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)
+  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)
+  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))
+  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))
+  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))
+  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)==false))
+  if((mitk::Equal(geometry->GetCornerPoint(0),cornerpoint0)==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->SetInputWorldGeometry(geometry);
+  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);
    }
 
    for (int i=0; i < (int)numSlices; i++)
    {
       mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
       geo2d->Initialize();
       geo2d->SetReferenceGeometry(geometry);
       slicedgeometry2->SetGeometry2D(geo2d,i);
    }
 
    slicedgeometry1->SetReferenceGeometry(geometry);
    slicedgeometry2->SetReferenceGeometry(geometry);
 
    //Create SNC
    mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
-   sliceCtrl1->SetInputWorldGeometry(slicedgeometry1);
+   sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
    sliceCtrl1->Update();
 
    mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
-   sliceCtrl2->SetInputWorldGeometry(slicedgeometry2);
+   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) )  ||
       ( !mitk::Equal(orientAxis1, newAxis1) )
       )
    {
       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);
     }
 
     for (int i=0; i < (int)numSlices; i++)
     {
       mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
       geo2d->Initialize();
       geo2d->SetReferenceGeometry(geometry);
       slicedgeometry2->SetGeometry2D(geo2d,i);
     }
 
     slicedgeometry1->SetReferenceGeometry(geometry);
     slicedgeometry2->SetReferenceGeometry(geometry);
 
     //Create SNC
     mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
-    sliceCtrl1->SetInputWorldGeometry(slicedgeometry1);
+    sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
     sliceCtrl1->Update();
 
     mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
-    sliceCtrl2->SetInputWorldGeometry(slicedgeometry2);
+    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);
     sliceCtrl1->ExecuteOperation(service->GetPlanePosition(0));
     sliceCtrl1->Update();
     mitk::Geometry2D* planeRotated = slicedgeometry2->GetGeometry2D(178);
     mitk::Geometry2D* planeRestored = dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetGeometry2D(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;
 
 
 
   //Testing  ReorientPlanes
   result = testReorientPlanes();
   if(result!=EXIT_SUCCESS)
      return result;
 
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
diff --git a/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp b/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
index 8f804a05e4..28a0fe6ed0 100644
--- a/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
+++ b/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
@@ -1,256 +1,255 @@
 /*===================================================================
 
 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 "mitkTimeSlicedGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkTestingMacros.h"
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.txx>
 
 #include <fstream>
 
 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::Geometry2D::Pointer geo2d = mitk::Geometry2D::New();
     geo2d->Initialize();
     slicedGeo3D->SetGeometry2D(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::Geometry3D* subSliceGeo2D_first = slicedGeo3D->GetGeometry2D(0);
   mitk::Geometry3D* subSliceGeo2D_last = slicedGeo3D->GetGeometry2D(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));
   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))==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false) ||
      (mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin())==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::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))==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetOrigin(), origin3last)==false) ||
      (mitk::Equal(accessedplanegeometry3last->GetIndexToWorldTransform()->GetOffset(), origin3last.GetVectorFromOrigin())==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));
   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))==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
      (mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false) ||
      (mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin())==false) ||
      (mitk::Equal(accessedplanegeometry3->GetIndexToWorldTransform()->GetOffset(), planegeometry3->GetOrigin().GetVectorFromOrigin())==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/Testing/mitkSurfaceTest.cpp b/Core/Code/Testing/mitkSurfaceTest.cpp
index 0aae3828e0..d18eef4f17 100644
--- a/Core/Code/Testing/mitkSurfaceTest.cpp
+++ b/Core/Code/Testing/mitkSurfaceTest.cpp
@@ -1,151 +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 "mitkSurface.h"
 #include "mitkCommon.h"
 #include "mitkVector.h"
 #include "mitkTestingMacros.h"
-#include "mitkTimeSlicedGeometry.h"
 
 #include "vtkPolyData.h"
 #include "vtkSphereSource.h"
 
 #include <fstream>
 
 int mitkSurfaceTest(int /*argc*/, char* /*argv*/[])
 {
 
   MITK_TEST_BEGIN("Surface");
 
   mitk::Surface::Pointer surface = mitk::Surface::New();
   MITK_TEST_CONDITION_REQUIRED( surface.GetPointer(), "Testing initialization!" );
 
   mitk::Surface::Pointer cloneSurface = surface->Clone();
   MITK_TEST_CONDITION_REQUIRED( cloneSurface.GetPointer(), "Testing clone surface initialization!" );
 
   vtkSphereSource* sphereSource = vtkSphereSource::New();
   sphereSource->SetCenter(0,0,0);
   sphereSource->SetRadius(5.0);
   sphereSource->SetThetaResolution(10);
   sphereSource->SetPhiResolution(10);
   sphereSource->Update();
 
   vtkPolyData* polys = sphereSource->GetOutput();
   MITK_TEST_CONDITION_REQUIRED(surface->GetVtkPolyData() == NULL, "Testing initial state of vtkPolyData");
   surface->SetVtkPolyData( polys );
   sphereSource->Delete();
   MITK_TEST_CONDITION_REQUIRED(surface->GetVtkPolyData()!= NULL, "Testing set vtkPolyData");
 
   cloneSurface= NULL;
   cloneSurface = surface->Clone();
   MITK_TEST_CONDITION_REQUIRED(cloneSurface->GetVtkPolyData()!= NULL, "Testing set vtkPolyData of cloned surface!");
   cloneSurface = NULL;
 
     vtkFloatingPointType bounds[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
     polys->ComputeBounds();
     polys->GetBounds( bounds );
 
     surface->UpdateOutputInformation();
     surface->SetRequestedRegionToLargestPossibleRegion();
     mitk::BoundingBox* bb = const_cast<mitk::BoundingBox*>(surface->GetGeometry()->GetBoundingBox());
     mitk::BoundingBox::BoundsArrayType surfBounds = bb->GetBounds();
 
     bool passed = false;
     if ( bounds[0] == surfBounds[0] && bounds[1] == surfBounds[1]
       && bounds[2] == surfBounds[2] && bounds[3] == surfBounds[3]
       && bounds[4] == surfBounds[4] && bounds[5] == surfBounds[5] )
     {
       passed = true;
     }
     MITK_TEST_CONDITION_REQUIRED(passed, "Testing GetBoundingBox()!");
 
   surface->Expand(5);
   surface->Update();
   surface->SetRequestedRegionToLargestPossibleRegion();
   mitk::Surface::RegionType requestedRegion = surface->GetRequestedRegion();
   MITK_TEST_CONDITION_REQUIRED(requestedRegion.GetSize(3) == 5, "Testing mitk::Surface::Expand( timesteps ): ");
 
   vtkFloatingPointType boundsMat[5][6];
 
   for (int i=0;i<5;i++) {
     vtkSphereSource* sphereSource = vtkSphereSource::New();
     sphereSource->SetCenter(0,0,0);
     sphereSource->SetRadius(1.0 * (i+1.0));
     sphereSource->SetThetaResolution(10);
     sphereSource->SetPhiResolution(10);
     sphereSource->Update();
     sphereSource->GetOutput()->ComputeBounds();
     sphereSource->GetOutput()->GetBounds( boundsMat[i] );
     surface->SetVtkPolyData( sphereSource->GetOutput(),i );
     sphereSource->Delete();
   }
 
   surface->UpdateOutputInformation();
   surface->SetRequestedRegionToLargestPossibleRegion();
 
   passed = true;
   for (int i=0;i<5;i++)
   {
-    mitk::BoundingBox::BoundsArrayType surfBounds = (const_cast<mitk::BoundingBox*>(surface->GetTimeSlicedGeometry()->GetGeometry3D(i)->GetBoundingBox()))->GetBounds();
+    mitk::BoundingBox::BoundsArrayType surfBounds = (const_cast<mitk::BoundingBox*>(surface->GetTimeGeometry()->GetGeometryForTimeStep(i)->GetBoundingBox()))->GetBounds();
 
     if ( boundsMat[i][0] != surfBounds[0]
     || boundsMat[i][1] != surfBounds[1]
     || boundsMat[i][2] != surfBounds[2]
     || boundsMat[i][3] != surfBounds[3]
     || boundsMat[i][4] != surfBounds[4]
     || boundsMat[i][5] != surfBounds[5] )
     {
       passed = false;
       break;
     }
   }
   MITK_TEST_CONDITION_REQUIRED(passed, "Testing mitk::Surface::Testing 4D surface data creation!" );
 
-  const mitk::TimeSlicedGeometry* inputTimeGeometry = surface->GetUpdatedTimeSlicedGeometry();
+  const mitk::TimeGeometry* inputTimeGeometry = surface->GetUpdatedTimeGeometry();
 
   int time = 3;
   int timestep=0;
-  timestep = inputTimeGeometry->MSToTimeStep( time );
-  MITK_TEST_CONDITION_REQUIRED(time == timestep, "Testing correctness of geometry for surface->GetUpdatedTimeSlicedGeometry()!");
+  timestep = inputTimeGeometry->TimePointToTimeStep( time );
+  MITK_TEST_CONDITION_REQUIRED(time == timestep, "Testing correctness of geometry for surface->GetUpdatedTimeGeometry()!");
 
   sphereSource = vtkSphereSource::New();
   sphereSource->SetCenter(0,0,0);
   sphereSource->SetRadius( 100.0 );
   sphereSource->SetThetaResolution(10);
   sphereSource->SetPhiResolution(10);
   sphereSource->Update();
   surface->SetVtkPolyData( sphereSource->GetOutput(), 3 );
   sphereSource->Delete();
 
-  inputTimeGeometry = surface->GetUpdatedTimeSlicedGeometry();
+  inputTimeGeometry = surface->GetUpdatedTimeGeometry();
   time = 3;
   timestep=0;
 
-  timestep = inputTimeGeometry->MSToTimeStep( time );
+  timestep = inputTimeGeometry->TimePointToTimeStep( time );
   MITK_TEST_CONDITION_REQUIRED(time == timestep, "Explicitly changing the data of timestep 3 and checking for timebounds correctness of surface's geometry again!");
 
   unsigned int numberoftimesteps = surface->GetTimeSteps();
   mitk::Surface::Pointer dummy = mitk::Surface::New();
   dummy->Graft(surface);
   MITK_TEST_CONDITION_REQUIRED( dummy->GetVtkPolyData() != NULL, "Testing copying a Surface with Graft()!");
   MITK_TEST_CONDITION_REQUIRED( dummy->GetTimeSteps() == numberoftimesteps, "orig-numberofTimeSteps:" << numberoftimesteps << "  copy-numberofTimeSteps:" << dummy->GetTimeSteps());
 
   surface = NULL;
   MITK_TEST_CONDITION_REQUIRED( surface.IsNull(), "Testing destruction of surface!");
 
   MITK_TEST_END();
 }
diff --git a/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp b/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp
index f5c8e15ddd..d907c0efea 100644
--- a/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp
+++ b/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp
@@ -1,122 +1,121 @@
 /*===================================================================
 
 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 "mitkSurface.h"
 #include "mitkSurfaceToSurfaceFilter.h"
 #include "mitkCommon.h"
 #include "mitkVector.h"
-#include "mitkTimeSlicedGeometry.h"
 
 #include "vtkPolyData.h"
 #include "vtkSphereSource.h"
 
 #include <fstream>
 
 int mitkSurfaceToSurfaceFilterTest(int /*argc*/, char* /*argv*/[])
 {
   mitk::Surface::Pointer surface;
   surface = mitk::Surface::New();
   vtkSphereSource* sphereSource = vtkSphereSource::New();
   sphereSource->SetCenter(0,0,0);
   sphereSource->SetRadius(5.0);
   sphereSource->SetThetaResolution(10);
   sphereSource->SetPhiResolution(10);
   sphereSource->Update();
 
   vtkPolyData* polys = sphereSource->GetOutput();
   surface->SetVtkPolyData( polys );
   sphereSource->Delete();
 
 
   mitk::SurfaceToSurfaceFilter::Pointer filter = mitk::SurfaceToSurfaceFilter::New();
   std::cout << "Testing mitk::SurfaceToSurfaceFilter::SetInput() and ::GetNumberOfInputs() : " ;
   filter->SetInput( surface );
   if ( filter->GetNumberOfInputs() < 1 )
   {
     std::cout<<"[FAILED] : zero inputs set "<<std::endl;
     return EXIT_FAILURE;
   }
 
 
   std::cout << "Testing if GetInput returns the right Input : " << std::endl;
   if ( filter->GetInput() != surface )
   {
     std::cout<<"[FAILED] : GetInput does not return correct input. "<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout << "[SUCCESS] : input correct" << std::endl;
 
 
   if ( filter->GetInput(5) != NULL )
   {
     std::cout<<"[FAILED] : GetInput returns inputs that were not set. "<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout << "[SUCCESS] : Input nr.5 was not set -> is NULL" << std::endl;
 
 
   std::cout << "Testing whether Output is created correctly : " << std::endl;
   if ( filter->GetNumberOfOutputs() != filter->GetNumberOfInputs() )
   {
     std::cout <<"[FAILED] : number of outputs != number of inputs" << std::endl;
     return EXIT_FAILURE;
   }
   std::cout << "[SUCCESS] : number of inputs == number of outputs." << std::endl;
 
 
   mitk::Surface::Pointer outputSurface = filter->GetOutput();
   if ( outputSurface->GetVtkPolyData()->GetNumberOfPolys() != surface->GetVtkPolyData()->GetNumberOfPolys() )
   {
     std::cout << "[FAILED] : number of Polys in PolyData of output != number of Polys in PolyData of input" << std::endl;
     return EXIT_FAILURE;
   }
   std::cout << "[SUCCESS] : number of Polys in PolyData of input and output are identical." << std::endl;
 
 
 
   filter->Update();
   outputSurface = filter->GetOutput();
   if ( outputSurface->GetSizeOfPolyDataSeries() != surface->GetSizeOfPolyDataSeries() )
   {
     std::cout << "[FAILED] : number of PolyDatas in PolyDataSeries of output != number of PolyDatas of input" << std::endl;
     return EXIT_FAILURE;
   }
   std::cout << "[SUCCESS] : Size of PolyDataSeries of input and output are identical." << std::endl;
 
 
   //std::cout << "Testing RemoveInputs() : " << std::endl;
   //unsigned int numOfInputs = filter->GetNumberOfInputs();
   //filter->RemoveInputs( mitk::Surface::New() );
   //if ( filter->GetNumberOfInputs() != numOfInputs )
   //{
   //  std::cout << "[FAILED] : input was removed that was not set." << std::endl;
   //  return EXIT_FAILURE;
   //}
   //std::cout << "[SUCCESS] : no input was removed that was not set." << std::endl;
   //filter->RemoveInputs( surface );
   //if ( filter->GetNumberOfInputs() != 0 )
   //{
   //  std::cout << "[FAILED] : existing input was not removed correctly." << std::endl;
   //  return EXIT_FAILURE;
   //}
   //std::cout << "[SUCCESS] : existing input was removed correctly." << std::endl;
 
 
 
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }
diff --git a/Core/Code/Testing/mitkTimeGeometryTest.cpp b/Core/Code/Testing/mitkTimeGeometryTest.cpp
new file mode 100644
index 0000000000..e32602f1ac
--- /dev/null
+++ b/Core/Code/Testing/mitkTimeGeometryTest.cpp
@@ -0,0 +1,774 @@
+/*===================================================================
+
+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 "mitkTimeGeometry.h"
+#include "mitkGeometry3D.h"
+
+#include "mitkRotationOperation.h"
+#include "mitkInteractionConst.h"
+#include <mitkMatrixConvert.h>
+#include <mitkImageCast.h>
+
+#include "mitkTestingMacros.h"
+#include <fstream>
+#include <mitkVector.h>
+
+
+#include <mitkStandaloneDataStorage.h>
+#include "mitkImageGenerator.h"
+#include "mitkPointSet.h"
+#include <limits>
+
+class mitkTimeGeometryTestClass
+{
+public:
+  void Translation_Image_MovedOrigin(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    // DimX, DimY, DimZ,
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::Geometry3D::Pointer geometry = image->GetTimeGeometry()->GetGeometryForTimeStep(0);
+    mitk::Point3D imageOrigin = geometry->GetOrigin();
+    mitk::Point3D expectedOrigin;
+    expectedOrigin[0] = 0;
+    expectedOrigin[1] = 0;
+    expectedOrigin[2] = 0;
+    MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Original origin match expected origin");
+
+    expectedOrigin[0] = 0.325;
+    expectedOrigin[1] = 0.487;
+    expectedOrigin[2] = 0.78;
+
+    mitk::Vector3D translationVector;
+    translationVector[0] = expectedOrigin[0];
+    translationVector[1] = expectedOrigin[1];
+    translationVector[2] = expectedOrigin[2];
+
+    for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->GetNumberOfTimeSteps(); ++timeStep)
+    {
+      image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep)->Translate(translationVector);
+    }
+    imageOrigin = image->GetGeometry(0)->GetOrigin();
+    MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Translated origin match expected origin");
+
+    expectedOrigin[0] = 2*translationVector[0];
+    expectedOrigin[1] = 2*translationVector[1];
+    expectedOrigin[2] = 2*translationVector[2];
+
+    for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->GetNumberOfTimeSteps(); ++timeStep)
+    {
+      image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep)->Translate(translationVector);
+    }
+    imageOrigin = image->GetGeometry(0)->GetOrigin();
+    MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Translated origin match expected origin");
+
+  }
+
+
+  void Rotate_Image_RotatedPoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
+    mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
+
+    // DimX, DimY, DimZ,
+    dataNode->SetData(baseData);
+    ds->Add(dataNode);
+    mitk::Geometry3D::Pointer geometry = baseData->GetTimeGeometry()->GetGeometryForTimeStep(0);
+    mitk::Point3D expectedPoint;
+    expectedPoint[0] = 3*0.5;
+    expectedPoint[1] = 3*0.33;
+    expectedPoint[2] = 3*0.78;
+    mitk::Point3D originalPoint;
+    originalPoint[0] = 3;
+    originalPoint[1] = 3;
+    originalPoint[2] = 3;
+    mitk::Point3D worldPoint;
+    geometry->IndexToWorld(originalPoint, worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Index-to-World without rotation as expected ");
+
+    mitk::Point3D pointOfRotation;
+    pointOfRotation[0] = 0;
+    pointOfRotation[1] = 0;
+    pointOfRotation[2] = 0;
+    mitk::Vector3D vectorOfRotation;
+    vectorOfRotation[0] = 1;
+    vectorOfRotation[1] = 0.5;
+    vectorOfRotation[2] = 0.2;
+    float angleOfRotation = 73.0;
+    mitk::RotationOperation* rotation = new mitk::RotationOperation(mitk::OpROTATE,pointOfRotation, vectorOfRotation, angleOfRotation);
+
+    baseData->GetTimeGeometry()->ExecuteOperation(rotation);
+    delete rotation;
+
+    expectedPoint[0] = 2.6080379;
+    expectedPoint[1] = -0.75265157;
+    expectedPoint[2] = 1.1564401;
+
+    baseData->GetGeometry(0)->IndexToWorld(originalPoint,worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Rotation returns expected values ");
+  }
+
+  void Scale_Image_ScaledPoint(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    // DimX, DimY, DimZ,
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::Geometry3D::Pointer geometry = image->GetTimeGeometry()->GetGeometryForTimeStep(0);
+    mitk::Point3D expectedPoint;
+    expectedPoint[0] = 3*0.5;
+    expectedPoint[1] = 3*0.33;
+    expectedPoint[2] = 3*0.78;
+    mitk::Point3D originalPoint;
+    originalPoint[0] = 3;
+    originalPoint[1] = 3;
+    originalPoint[2] = 3;
+    mitk::Point3D worldPoint;
+    geometry->IndexToWorld(originalPoint, worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Index-to-World with old Scaling as expected ");
+
+    mitk::Vector3D newSpacing;
+    newSpacing[0] = 2;
+    newSpacing[1] = 1.254;
+    newSpacing[2] = 0.224;
+    image->SetSpacing(newSpacing);
+    mitk::BaseData* base;
+    expectedPoint[0] = 3*2;
+    expectedPoint[1] = 3*1.254;
+    expectedPoint[2] = 3*0.224;
+
+    image->GetGeometry(0)->IndexToWorld(originalPoint,worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Index-toWorld with new Scaling returns expected values ");
+  }
+
+  void GetMinimumTimePoint_4DBaseData_Zero(mitk::BaseData* baseData, unsigned int DimT)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimePointType expectedTimePoint = geometry->GetMinimumTimePoint();
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, 0), "Returns correct minimum time point ");
+  }
+
+  void GetMaximumTimePoint_4DBaseData_DimT(mitk::BaseData* baseData, unsigned int DimT)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimePointType expectedTimePoint = geometry->GetMaximumTimePoint();
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, DimT), "Returns correct maximum time point ");
+  }
+
+    void GetNumberOfTimeSteps_Image_ReturnDimT(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimeStepType expectedTimeSteps = geometry->GetNumberOfTimeSteps();
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimeSteps, DimT), "Returns correct number of time Steps ");
+  }
+
+    void GetMinimumTimePoint_3DImage_Min(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimePointType expectedTimePoint = geometry->GetMinimumTimePoint();
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, -std::numeric_limits<mitk::TimePointType>().max()), "Returns correct minimum time point ");
+  }
+
+    void GetMaximumTimePoint_3DImage_Max(mitk::BaseData* baseData,unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimePointType expectedTimePoint = geometry->GetMaximumTimePoint();
+    MITK_INFO << expectedTimePoint;
+    MITK_INFO << std::numeric_limits<mitk::TimePointType>().max();
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, std::numeric_limits<mitk::TimePointType>().max()), "Returns correct maximum time point ");
+  }
+
+  void GetTimeBounds_4DImage_ZeroAndDimT(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+    mitk::TimeBounds expectedTimeBounds = geometry->GetTimeBounds();
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[0], 0), "Returns correct minimum time point ");
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[1], DimT), "Returns correct maximum time point ");
+  }
+
+  void GetTimeBounds_3DImage_ZeroAndDimT(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimeBounds expectedTimeBounds = geometry->GetTimeBounds();
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[0], -std::numeric_limits<mitk::TimePointType>().max()), "Returns correct minimum time point ");
+    MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[1], std::numeric_limits<mitk::TimePointType>().max()), "Returns correct maximum time point ");
+  }
+
+  void IsValidTimePoint_ImageValidTimePoint_True(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    bool isValid = geometry->IsValidTimePoint(DimT-1);
+    MITK_TEST_CONDITION(mitk::Equal(isValid, true), "Is valid time Point correct minimum time point ");
+  }
+
+  void IsValidTimePoint_ImageNegativInvalidTimePoint_False(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+    bool isValid = geometry->IsValidTimePoint(-DimT);
+    MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
+  }
+
+  void IsValidTimePoint_ImageInvalidTimePoint_False(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+    bool isValid = geometry->IsValidTimePoint(DimT+1);
+    MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
+  }
+
+  void IsValidTimeStep_ImageValidTimeStep_True(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    bool isValid = geometry->IsValidTimeStep(DimT-1);
+    MITK_TEST_CONDITION(mitk::Equal(isValid, true), "Is valid time Point correct minimum time point ");
+  }
+
+  void IsValidTimeStep_ImageNegativInvalidTimeStep_False(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    bool isValid = geometry->IsValidTimeStep(-DimT);
+    MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
+  }
+
+  void IsValidTimeStep_ImageInvalidTimeStep_False(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    bool isValid = geometry->IsValidTimeStep(DimT);
+    MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
+  }
+
+  void TimeStepToTimePoint_ImageValidTimeStep_TimePoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimePointType timePoint= geometry->TimeStepToTimePoint(DimT-1);
+    MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT-1), "Calculated right time Point for Time Step ");
+  }
+
+  void TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimePointType timePoint= geometry->TimeStepToTimePoint(DimT+1);
+    MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT+1), "Calculated right time Point for invalid Time Step ");
+  }
+
+  void TimePointToTimeStep_ImageValidTimePoint_TimePoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::TimeStepType timePoint= geometry->TimePointToTimeStep(DimT-0.5);
+    MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT-1), "Calculated right time step for valid time point");
+  }
+
+  void TimePointToTimeStep_4DImageInvalidTimePoint_TimePoint(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+    mitk::TimeStepType timePoint= geometry->TimePointToTimeStep(DimT+1.5);
+    MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT+1), "Calculated right time step for invalid time point");
+  }
+
+  void TimePointToTimeStep_4DImageNegativInvalidTimePoint_TimePoint(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+    mitk::TimePointType negativTimePoint = (-1.0*DimT) - 1.5;
+    mitk::TimeStepType timePoint= geometry->TimePointToTimeStep(negativTimePoint);
+    MITK_TEST_CONDITION(mitk::Equal(timePoint, 0), "Calculated right time step for negativ invalid time point");
+  }
+
+  void GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData* baseData,
+    float inputX, float inputY, float inputZ,
+    float outputX, float outputY, float outputZ, unsigned int DimT)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT-1);
+    MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
+
+    mitk::Point3D expectedPoint;
+    expectedPoint[0] = outputX;
+    expectedPoint[1] = outputY;
+    expectedPoint[2] = outputZ;
+    mitk::Point3D originalPoint;
+    originalPoint[0] = inputX;
+    originalPoint[1] = inputY;
+    originalPoint[2] = inputZ;
+    mitk::Point3D worldPoint;
+    geometry3D->IndexToWorld(originalPoint, worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation match expection. ");
+  }
+
+  void GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT+1);
+    MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned");
+  }
+
+  void GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(mitk::BaseData* baseData,
+    float inputX, float inputY, float inputZ,
+    float outputX, float outputY, float outputZ, unsigned int DimT)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimePoint(DimT-0.5);
+    MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
+
+    mitk::Point3D expectedPoint;
+    expectedPoint[0] = outputX;
+    expectedPoint[1] = outputY;
+    expectedPoint[2] = outputZ;
+    mitk::Point3D originalPoint;
+    originalPoint[0] = inputX;
+    originalPoint[1] = inputY;
+    originalPoint[2] = inputZ;
+    mitk::Point3D worldPoint;
+    geometry3D->IndexToWorld(originalPoint, worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation match expection. ");
+  }
+
+  void GetGeometryForTimePoint_4DImageInvalidTimePoint_NullPointer(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimePoint(DimT+1);
+    MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned with invalid time point");
+  }
+
+  void GetGeometryForTimePoint_4DImageNEgativInvalidTimePoint_NullPointer(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+    mitk::TimePointType timePoint = (-1.0*(DimT)) -1;
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimePoint(timePoint);
+    MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned with invalid negativ time point");
+  }
+
+  void GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData* baseData, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT-1);
+    MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
+
+    mitk::Point3D expectedPoint;
+    mitk::Point3D originalPoint;
+    originalPoint[0] = 3;
+    originalPoint[1] = 3;
+    originalPoint[2] = 3;
+    mitk::Point3D worldPoint;
+    geometry3D->IndexToWorld(originalPoint, expectedPoint);
+
+    mitk::Vector3D translationVector;
+    translationVector[0] = 5;
+    translationVector[1] = 8;
+    translationVector[2] = 7;
+    geometry3D->Translate(translationVector);
+
+    geometry3D = geometry->GetGeometryForTimeStep(DimT-1);
+    geometry3D->IndexToWorld(originalPoint, worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation not changed. ");
+  }
+
+  void GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT+1);
+    MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned");
+  }
+
+  void SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData* baseData, float scaleX, float scaleY, float scaleZ, unsigned int DimT)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT-1);
+    MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
+
+    mitk::Vector3D translationVector;
+    translationVector[0] = 5;
+    translationVector[1] = 8;
+    translationVector[2] = 7;
+    geometry3D->Translate(translationVector);
+
+    geometry->SetTimeStepGeometry(geometry3D,DimT-1);
+
+    mitk::Point3D expectedPoint;
+    expectedPoint[0] = 3*scaleX+5;
+    expectedPoint[1] = 3*scaleY+8;
+    expectedPoint[2] = 3*scaleZ+7;
+    mitk::Point3D originalPoint;
+    originalPoint[0] = 3;
+    originalPoint[1] = 3;
+    originalPoint[2] = 3;
+    mitk::Point3D worldPoint;
+    geometry->GetGeometryForTimeStep(DimT-1)->IndexToWorld(originalPoint, worldPoint);
+    MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation match expection. ");
+  }
+
+  void Expand_BaseDataDoubleSize_SizeChanged(mitk::BaseData* baseData, int DimT)
+  {
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+    MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==DimT, "Number of time Steps match expection. ");
+
+    geometry->Expand(DimT * 2);
+    MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==DimT*2, "Number of time Steps match expection. ");
+
+    mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT*2 -1);
+    MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry is generated. ");
+  }
+
+  void CheckBounds_BaseData_PointsAsExpected(mitk::BaseData* baseData, float minX, float minY, float minZ, float maxX, float maxY, float maxZ)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+
+    mitk::Point3D expectedPoint;
+
+    expectedPoint[0] = minX;
+    expectedPoint[1] = minY;
+    expectedPoint[2] = minZ;
+    mitk::Point3D point =  geometry->GetCornerPointInWorld(0);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 0 as expected ");
+    point =  geometry->GetCornerPointInWorld(true,true,true);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 0 as expected ");
+
+    point =  geometry->GetCornerPointInWorld(1);
+    expectedPoint[0] = minX;
+    expectedPoint[1] = minY;
+    expectedPoint[2] = maxZ;
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "GBounding Point 1 as expected ");
+    point =  geometry->GetCornerPointInWorld(true,true,false);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 1 as expected ");
+
+    point =  geometry->GetCornerPointInWorld(2);
+    expectedPoint[0] = minX;
+    expectedPoint[1] = maxY;
+    expectedPoint[2] = minZ;
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 2 as expected ");
+    point =  geometry->GetCornerPointInWorld(true,false,true);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 2 as expected ");
+
+    point =  geometry->GetCornerPointInWorld(3);
+    expectedPoint[0] = minX;
+    expectedPoint[1] = maxY;
+    expectedPoint[2] = maxZ;
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 3 as expected  ");
+    point =  geometry->GetCornerPointInWorld(true,false,false);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 3 as expected ");
+
+    point =  geometry->GetCornerPointInWorld(4);
+    expectedPoint[0] = maxX;
+    expectedPoint[1] = minY;
+    expectedPoint[2] = minZ;
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 4 as expected  ");
+    point =  geometry->GetCornerPointInWorld(false,true,true);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 4 as expected ");
+
+    point =  geometry->GetCornerPointInWorld(5);
+    expectedPoint[0] = maxX;
+    expectedPoint[1] = minY;
+    expectedPoint[2] = maxZ;
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 5 as expected  ");
+    point =  geometry->GetCornerPointInWorld(false,true,false);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 5 as expected ");
+
+    point =  geometry->GetCornerPointInWorld(6);
+    expectedPoint[0] = maxX;
+    expectedPoint[1] = maxY;
+    expectedPoint[2] = minZ;
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 6 as expected  ");
+    point =  geometry->GetCornerPointInWorld(false,false,true);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 6 as expected ");
+
+    point =  geometry->GetCornerPointInWorld(7);
+    expectedPoint[0] = maxX;
+    expectedPoint[1] = maxY;
+    expectedPoint[2] = maxZ;
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 7 as expected  ");
+    point =  geometry->GetCornerPointInWorld(false,false,false);
+    MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 7 as expected ");
+  }
+
+  void CheckLength_BaseData_AsExpected(mitk::BaseData* baseData, double length, double squareLength)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+
+    double dimension = geometry->GetDiagonalLengthInWorld();
+    MITK_TEST_CONDITION(mitk::Equal(dimension,length ), "Length  as expected ");
+
+    dimension = geometry->GetDiagonalLength2InWorld();
+    MITK_TEST_CONDITION(mitk::Equal(dimension, squareLength ), "Square length as expected ");
+  }
+
+  void CheckPointInside_BaseDataPointInside_True(mitk::BaseData* baseData, float pointX, float pointY, float pointZ)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+
+    mitk::Point3D expectedPoint;
+
+    expectedPoint[0] = pointX;
+    expectedPoint[1] = pointY;
+    expectedPoint[2] = pointZ;
+    bool isInside =  geometry->IsWorldPointInside(expectedPoint);
+    MITK_TEST_CONDITION(isInside, "Point is inside Image...");
+  }
+
+  void CheckPointInside_BaseDataPointOutside_False(mitk::BaseData* baseData, float pointX, float pointY, float pointZ)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+
+    mitk::Point3D expectedPoint;
+
+    expectedPoint[0] = pointX;
+    expectedPoint[1] = pointY;
+    expectedPoint[2] = pointZ;
+    bool isInside =  geometry->IsWorldPointInside(expectedPoint);
+    MITK_TEST_CONDITION(!isInside, "Point is outside Image...");
+  }
+
+  void CheckBounds_Image_AsSet(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+  {
+    mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
+    mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
+
+    mitk::BoundingBox::BoundsArrayType bound =  geometry->GetBoundsInWorld();
+    bool isEqual = true;
+    isEqual = isEqual && mitk::Equal(bound[0], -0.5*0.5);
+    isEqual = isEqual && mitk::Equal(bound[1], 29.5*0.5);
+    isEqual = isEqual && mitk::Equal(bound[2], -0.5*0.33);
+    isEqual = isEqual && mitk::Equal(bound[3], 24.5*0.33);
+    isEqual = isEqual && mitk::Equal(bound[4], -0.5*0.78);
+    isEqual = isEqual && mitk::Equal(bound[5], 19.5*0.78);
+
+    MITK_TEST_CONDITION(isEqual, "Bounds as precalculated...");
+  }
+
+  void CheckBounds_BaseData_AsSet(mitk::BaseData* baseData, float minBoundX, float maxBoundX, float minBoundY, float maxBoundY, float minBoundZ, float maxBoundZ)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+
+    mitk::BoundingBox::BoundsArrayType bound =  geometry->GetBoundsInWorld();
+    bool isEqual = true;
+    isEqual = isEqual && mitk::Equal(bound[0], minBoundX);
+    isEqual = isEqual && mitk::Equal(bound[1], maxBoundX);
+    isEqual = isEqual && mitk::Equal(bound[2], minBoundY);
+    isEqual = isEqual && mitk::Equal(bound[3], maxBoundY);
+    isEqual = isEqual && mitk::Equal(bound[4], minBoundZ);
+    isEqual = isEqual && mitk::Equal(bound[5], maxBoundZ);
+
+    MITK_TEST_CONDITION(isEqual, "Bounds as precalculated...");
+  }
+
+  void CheckExtent_BaseData_AsSet(mitk::BaseData* baseData, double extentX, double extentY, double extentZ)
+  {
+    baseData->Update();
+    mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
+
+    mitk::BoundingBox::BoundsArrayType bound =  geometry->GetBoundsInWorld();
+    bool isEqual = true;
+    isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(0), extentX);//30*0.5);
+    isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(1), extentY);//25*0.33);
+    isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(2), extentZ);//20*0.78);
+
+    MITK_TEST_CONDITION(isEqual, "Extent as precalculated...");
+  }
+
+  mitk::PointSet::Pointer makePointset()
+  {
+    mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
+    mitk::Point3D pointA, pointB, pointC;
+    pointA.Fill(1);
+    pointB.Fill(2);
+    pointC.Fill(3);
+    pointSet->SetPoint(1,pointA);
+    pointSet->SetPoint(2,pointB);
+    pointSet->SetPoint(3,pointC);
+    pointSet->Update();
+    MITK_INFO<< pointSet->GetPoint(0);
+    MITK_INFO<< pointSet->GetPoint(1);
+    MITK_INFO<< pointSet->GetPoint(2);
+    MITK_INFO<< pointSet->GetPoint(3);
+
+    mitk::PointSet::Pointer pointSet2 = pointSet->Clone();
+    MITK_INFO<< pointSet2->GetPoint(0);
+    MITK_INFO<< pointSet2->GetPoint(1);
+    MITK_INFO<< pointSet2->GetPoint(2);
+    MITK_INFO<< pointSet2->GetPoint(3);
+
+    return pointSet;
+  }
+};
+
+
+
+
+
+
+
+int mitkTimeGeometryTest(int /*argc*/, char* /*argv*/[])
+{
+  MITK_TEST_BEGIN(mitkTimeGeometryTest);
+
+  mitkTimeGeometryTestClass testClass;
+
+  MITK_TEST_OUTPUT(<< "Test for 3D image");
+  mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(30, 25, 20, 1,0.5,0.33,0.78,100);
+  testClass.Translation_Image_MovedOrigin(30,25,20,1);
+  testClass.Rotate_Image_RotatedPoint(image->Clone(),30,25,20,1);
+  testClass.Scale_Image_ScaledPoint(30,25,20,1);
+  testClass.GetNumberOfTimeSteps_Image_ReturnDimT(image->Clone(),30,25,20,1);
+  testClass.GetMinimumTimePoint_3DImage_Min(image->Clone(),30,25,20,1);
+  testClass.GetMaximumTimePoint_3DImage_Max(image->Clone(),30,25,20,1);
+  testClass.GetTimeBounds_3DImage_ZeroAndDimT(image->Clone(),30,25,20,1);
+  testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(),30,25,20,1);
+  testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30,25,20,1);
+  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30,25,20,1);
+  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30,25,20,1);
+  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30,25,20,1);
+  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30,25,20,1);
+  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30,25,20,1);
+  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
+  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,1);
+  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
+  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),1);
+  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,1);
+  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),0.5,0.33,0.78,1);
+  testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(),1);
+  testClass.CheckBounds_BaseData_PointsAsExpected(image->Clone(),-0.5*0.5,-0.5*0.33,-0.5*0.78,29.5*0.5,24.5*0.33,19.5*0.78);
+  testClass.CheckLength_BaseData_AsExpected(image->Clone(), 23.160796233014466, 536.42248214721712);
+  testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(),10,5,5);
+  testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(),100,500,100);
+  testClass.CheckBounds_Image_AsSet(30,25,20,1);
+  testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30*0.5,25*0.33,20*0.78);
+
+
+
+  MITK_TEST_OUTPUT(<< "Test for 2D image");
+  image = mitk::ImageGenerator::GenerateRandomImage<float>(30, 25, 1, 1,0.5,0.33,0.78,100);
+  testClass.Translation_Image_MovedOrigin(30,25,1,1);
+  testClass.Rotate_Image_RotatedPoint(image->Clone(),30,25,1,1);
+  testClass.Scale_Image_ScaledPoint(30,25,1,1);
+  testClass.GetNumberOfTimeSteps_Image_ReturnDimT(image->Clone(),30,25,1,1);
+  testClass.GetMinimumTimePoint_3DImage_Min(image->Clone(),30,25,1,1);
+  testClass.GetMaximumTimePoint_3DImage_Max(image->Clone(),30,25,1,1);
+  testClass.GetTimeBounds_3DImage_ZeroAndDimT(image->Clone(),30,25,1,1);
+  testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(),30,25,1,1);
+  testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30,25,1,1);
+  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30,25,1,1);
+  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30,25,1,1);
+  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30,25,1,1);
+  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30,25,1,1);
+  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30,25,1,1);
+  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
+  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,1,1);
+  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
+  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),1);
+  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,1,1);
+  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),0.5,0.33,0.78,1);
+  testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(),1);
+  testClass.CheckBounds_BaseData_PointsAsExpected(image->Clone(),-0.5*0.5,-0.5*0.33,-0.5*0.78,29.5*0.5,24.5*0.33,0.5*0.78);
+  testClass.CheckLength_BaseData_AsExpected(image->Clone(), 17.1368287615, 293.6709);
+  testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(),10,5,0);
+  testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(),100,500,0.5);
+  testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30*0.5,25*0.33,1*0.78);
+
+  MITK_TEST_OUTPUT(<< "Test for 3D+time image");
+  image = mitk::ImageGenerator::GenerateRandomImage<float>(30, 25, 20, 5,0.5,0.33,0.78,100);
+  testClass.Translation_Image_MovedOrigin(30,25,20,5); // Test with 3D+t-Image
+  testClass.Rotate_Image_RotatedPoint(image->Clone(),30,25,20,5); // Test with 3D+t-Image
+  testClass.Scale_Image_ScaledPoint(30,25,20,5); // Test with 3D+t-Image
+  testClass.GetNumberOfTimeSteps_Image_ReturnDimT(image->Clone(),30,25,20,5);
+  testClass.GetMinimumTimePoint_4DBaseData_Zero(image->Clone(),5);
+  testClass.GetMaximumTimePoint_4DBaseData_DimT(image->Clone(),5);
+  testClass.GetTimeBounds_4DImage_ZeroAndDimT(30,25,20,5);
+  testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(),30,25,20,5);
+  testClass.IsValidTimePoint_ImageNegativInvalidTimePoint_False(30,25,20,5);
+  testClass.IsValidTimePoint_ImageInvalidTimePoint_False(30,25,20,5);
+  testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30,25,20,5);
+  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30,25,20,5);
+  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30,25,20,5);
+  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30,25,20,5);
+  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30,25,20,5);
+  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30,25,20,5);
+  testClass.TimePointToTimeStep_4DImageInvalidTimePoint_TimePoint(30,25,20,5);
+  testClass.TimePointToTimeStep_4DImageNegativInvalidTimePoint_TimePoint(30,25,20,5);
+  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,5);
+  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,5);
+  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,5);
+  testClass.GetGeometryForTimePoint_4DImageInvalidTimePoint_NullPointer(30,25,20,5);
+  testClass.GetGeometryForTimePoint_4DImageNEgativInvalidTimePoint_NullPointer(30,25,20,5);
+  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),5);
+  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,5);
+  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),0.5,0.33,0.78,5);
+  testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(),5);
+  testClass.CheckBounds_BaseData_PointsAsExpected(image->Clone(),-0.5*0.5,-0.5*0.33,-0.5*0.78,29.5*0.5,24.5*0.33,19.5*0.78);
+  testClass.CheckLength_BaseData_AsExpected(image->Clone(), 23.160796233014466, 536.42248214721712);
+  testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(),10,5,5);
+  testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(), 100,100,500);
+  testClass.CheckBounds_Image_AsSet(30,25,20,5);
+  testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30*0.5,25*0.33,20*0.78);
+
+/*
+  MITK_TEST_OUTPUT(<< "Test for 2D+time image");
+  testClass.Translation_Image_MovedOrigin(30,25,1 ,5); // Test with 2D+t-Image
+  testClass.Rotate_Image_RotatedPoint(30,25,1 ,5); // Test with 2D+t-Image
+  testClass.Scale_Image_ScaledPoint(30,25,1 ,5); // Test with 2D+t-Image
+*/
+
+
+  mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
+  mitk::Point3D pointA, pointB, pointC;
+  pointA.Fill(1);
+  pointB.Fill(2);
+  pointC.Fill(3);
+  pointSet->SetPoint(0,pointA);
+  pointSet->SetPoint(1,pointB);
+  pointSet->SetPoint(2,pointC);
+  testClass.GetNumberOfTimeSteps_Image_ReturnDimT(pointSet->Clone(),30,25,20,1);
+  testClass.GetMinimumTimePoint_3DImage_Min(pointSet->Clone(),30,25,20,1);
+  testClass.GetMaximumTimePoint_3DImage_Max(pointSet->Clone(),30,25,20,1);
+  testClass.GetTimeBounds_3DImage_ZeroAndDimT(pointSet->Clone(),30,25,20,1);
+  testClass.IsValidTimePoint_ImageValidTimePoint_True(pointSet->Clone(),30,25,20,1);
+  testClass.IsValidTimeStep_ImageValidTimeStep_True(pointSet->Clone(),30,25,20,1);
+  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(pointSet->Clone(),30,25,20,1);
+  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(pointSet->Clone(),30,25,20,1);
+  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(pointSet->Clone(),30,25,20,1);
+  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(pointSet->Clone(),30,25,20,1);
+  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(pointSet->Clone(),30,25,20,1);
+  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(), 3,3,3,3,3,3,1);
+  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(pointSet->Clone(), 30,25,20,1);
+  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(pointSet->Clone(), 3,3,3,3,3,3,1);
+  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(),1);
+  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(pointSet->Clone(), 30,25,20,1);
+  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(), 1,1,1,1);
+  testClass.Expand_BaseDataDoubleSize_SizeChanged(pointSet->Clone(),1);
+  testClass.CheckBounds_BaseData_PointsAsExpected(pointSet->Clone(),1,1,1,3,3,3);
+  testClass.CheckLength_BaseData_AsExpected(pointSet->Clone(),3.46410161,12);
+  testClass.CheckPointInside_BaseDataPointInside_True(pointSet->Clone(),2,2,3);
+  testClass.CheckPointInside_BaseDataPointOutside_False(pointSet->Clone(),4,5,1);
+  testClass.CheckBounds_BaseData_AsSet(pointSet->Clone(),1,3,1,3,1,3);
+  testClass.CheckExtent_BaseData_AsSet(pointSet->Clone(),2,2,2 );
+
+  MITK_TEST_END();
+
+
+  return EXIT_SUCCESS;
+}
diff --git a/Core/Code/Testing/mitkTimeSlicedGeometryTest.cpp b/Core/Code/Testing/mitkTimeSlicedGeometryTest.cpp
deleted file mode 100644
index c51954516e..0000000000
--- a/Core/Code/Testing/mitkTimeSlicedGeometryTest.cpp
+++ /dev/null
@@ -1,453 +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 "mitkImage.h"
-#include "mitkPlaneGeometry.h"
-#include "mitkTimeSlicedGeometry.h"
-#include "mitkSlicedGeometry3D.h"
-#include "mitkGeometry2D.h"
-#include "mitkTestingMacros.h"
-
-#include <vnl/vnl_quaternion.h>
-#include <vnl/vnl_quaternion.txx>
-
-#include <fstream>
-
-
-void mitkTimeSlicedGeometry_ChangeImageGeometryConsideringOriginOffset_Test()
-{
-  // additional tests to check the function ChangeImageGeometryConsideringOriginOffset(..)
-
-  //first create a new timeslicedgeometry
-  mitk::TimeSlicedGeometry::Pointer geoTime = mitk::TimeSlicedGeometry::New();
-  mitk::Geometry3D::Pointer geo3d = mitk::Geometry3D::New();
-  geo3d->Initialize();
-  int numOfTimeSteps = 5;
-  geoTime->InitializeEvenlyTimed(geo3d, numOfTimeSteps);
-
-  for (int i=0; i < numOfTimeSteps; i++)
-  {
-    mitk::Geometry3D::Pointer geo3d_sub = mitk::Geometry3D::New();
-    geo3d_sub->Initialize();
-    geoTime->SetGeometry3D(geo3d_sub, i);
-  }
-
-  MITK_TEST_OUTPUT( << "Testing whether geoTime->GetImageGeometry() is false by default");
-  MITK_TEST_CONDITION_REQUIRED( geoTime->GetImageGeometry()==false, "");
-  MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the geoTime have GetImageGeometry()==false by default");
-  mitk::Geometry3D* subSliceGeo3D_first = geoTime->GetGeometry3D(0);
-  mitk::Geometry3D* subSliceGeo3D_last  = geoTime->GetGeometry3D(numOfTimeSteps-1);
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetImageGeometry()==false, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetImageGeometry()==false, "");
-
-  // Save some Origins and cornerpoints
-  mitk::Point3D OriginTimeGeo( geoTime->GetOrigin() );
-  mitk::Point3D OriginFirstGeo( subSliceGeo3D_first->GetOrigin() );
-  mitk::Point3D OriginLastGeo( subSliceGeo3D_last->GetOrigin() );
-  mitk::Point3D CornerPoint0TimeGeo(geoTime->GetCornerPoint(0));
-  mitk::Point3D CornerPoint1FirstGeo(subSliceGeo3D_first->GetCornerPoint(1));
-  mitk::Point3D CornerPoint2LastGeo(subSliceGeo3D_last->GetCornerPoint(2));
-
-  //std::cout << "vorher Origin: " << subSliceGeo3D_first->GetOrigin() << std::endl;
-  //std::cout << "vorher Corner: " << subSliceGeo3D_first->GetCornerPoint(0) << std::endl;
-  MITK_TEST_OUTPUT( << "Calling geoTime->ChangeImageGeometryConsideringOriginOffset(true)");
-  geoTime->ChangeImageGeometryConsideringOriginOffset(true);
-  //std::cout << "nachher Origin: " << subSliceGeo3D_first->GetOrigin() << std::endl;
-  //std::cout << "nachher Corner: " << subSliceGeo3D_first->GetCornerPoint(0) << std::endl;
-
-  MITK_TEST_OUTPUT( << "Testing whether geoTime->GetImageGeometry() is now true");
-  MITK_TEST_CONDITION_REQUIRED( geoTime->GetImageGeometry()==true, "");
-  MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==true now");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetImageGeometry()==true, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetImageGeometry()==true, "");
-
-  MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins");
-  // Manually adding Offset.
-  OriginTimeGeo[0] += (geoTime->GetSpacing()[0]) / 2;
-  OriginTimeGeo[1] += (geoTime->GetSpacing()[1]) / 2;
-  OriginTimeGeo[2] += (geoTime->GetSpacing()[2]) / 2;
-  OriginFirstGeo[0] += (subSliceGeo3D_first->GetSpacing()[0]) / 2;
-  OriginFirstGeo[1] += (subSliceGeo3D_first->GetSpacing()[1]) / 2;
-  OriginFirstGeo[2] += (subSliceGeo3D_first->GetSpacing()[2]) / 2;
-  OriginLastGeo[0] += (subSliceGeo3D_last->GetSpacing()[0]) / 2;
-  OriginLastGeo[1] += (subSliceGeo3D_last->GetSpacing()[1]) / 2;
-  OriginLastGeo[2] += (subSliceGeo3D_last->GetSpacing()[2]) / 2;
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( geoTime->GetCornerPoint(0)==CornerPoint0TimeGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( geoTime->GetOrigin()==OriginTimeGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetOrigin()==OriginFirstGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetOrigin()==OriginLastGeo, "");
-
-
-  MITK_TEST_OUTPUT( << "Calling geoTime->ChangeImageGeometryConsideringOriginOffset(false)");
-  geoTime->ChangeImageGeometryConsideringOriginOffset(false);
-  MITK_TEST_OUTPUT( << "Testing whether geoTime->GetImageGeometry() is now false");
-  MITK_TEST_CONDITION_REQUIRED( geoTime->GetImageGeometry()==false, "");
-  MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the geoTime have GetImageGeometry()==false now");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetImageGeometry()==false, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetImageGeometry()==false, "");
-
-  MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins");
-  // Manually substracting Offset.
-  OriginTimeGeo[0] -= (geoTime->GetSpacing()[0]) / 2;
-  OriginTimeGeo[1] -= (geoTime->GetSpacing()[1]) / 2;
-  OriginTimeGeo[2] -= (geoTime->GetSpacing()[2]) / 2;
-  OriginFirstGeo[0] -= (subSliceGeo3D_first->GetSpacing()[0]) / 2;
-  OriginFirstGeo[1] -= (subSliceGeo3D_first->GetSpacing()[1]) / 2;
-  OriginFirstGeo[2] -= (subSliceGeo3D_first->GetSpacing()[2]) / 2;
-  OriginLastGeo[0] -= (subSliceGeo3D_last->GetSpacing()[0]) / 2;
-  OriginLastGeo[1] -= (subSliceGeo3D_last->GetSpacing()[1]) / 2;
-  OriginLastGeo[2] -= (subSliceGeo3D_last->GetSpacing()[2]) / 2;
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( geoTime->GetCornerPoint(0)==CornerPoint0TimeGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( geoTime->GetOrigin()==OriginTimeGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetOrigin()==OriginFirstGeo, "");
-  MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetOrigin()==OriginLastGeo, "");
-
-}
-
-
-int mitkTimeSlicedGeometryTest(int /*argc*/, char* /*argv*/[])
-{
-  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*0.5;
-  height = 200;    heightInMM = height*1.2;
-  thicknessInMM = 1.5;
-  mitk::FillVector3D(origin,       2.5,       -3.3, 17.2);
-  mitk::FillVector3D(right,  widthInMM,          0, 0);
-  mitk::FillVector3D(bottom,         0, heightInMM, 0);
-  mitk::FillVector3D(normal,         0,          0, thicknessInMM);
-
-
-  std::cout << "Creating TimeSlicedGeometry" <<std::endl;
-  mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry = mitk::TimeSlicedGeometry::New();
-  if(timeSlicedGeometry.IsNull())
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  unsigned int numOfTimeSteps = 5;
-  std::cout << "Testing TimeSlicedGeometry::Initialize(timesteps = " << numOfTimeSteps << "): " <<std::endl;
-  timeSlicedGeometry->InitializeEvenlyTimed(numOfTimeSteps);
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::GetTimeSteps()==" << numOfTimeSteps << ": " <<std::endl;
-  if(timeSlicedGeometry->GetTimeSteps()!=numOfTimeSteps)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed(): " <<std::endl;
-  if(timeSlicedGeometry->GetEvenlyTimed()!=true)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-
-
-  mitk::TimeBounds timeBounds1;
-  timeBounds1[0] = 1.3;
-  timeBounds1[1] = 2.4;
-
-  std::cout << "Initializing a PlaneGeometry by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
-  planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector());
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Setting TimeBounds of PlaneGeometry by SetTimeBounds(): "<<std::endl;
-  planegeometry->SetTimeBounds(timeBounds1);
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing PlaneGeometry::GetTimeBounds(): "<<std::endl;
-  if(planegeometry->GetTimeBounds() != timeBounds1)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-
-  --numOfTimeSteps;
-  std::cout << "Testing TimeSlicedGeometry::InitializeEvenlyTimed(planegeometry, timesteps = " << numOfTimeSteps << "): " <<std::endl;
-  mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry2 = mitk::TimeSlicedGeometry::New();
-  timeSlicedGeometry2->InitializeEvenlyTimed(planegeometry, numOfTimeSteps);
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::GetTimeSteps()==" << numOfTimeSteps << ": " <<std::endl;
-  if(timeSlicedGeometry2->GetTimeSteps() != numOfTimeSteps)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed(): " <<std::endl;
-  if(timeSlicedGeometry2->GetEvenlyTimed()!=true)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::TimeStepToMS(): " << std::endl;
-  if(fabs(timeSlicedGeometry2->TimeStepToMS( 2 ) - 3.5) > mitk::eps)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::MSToTimeStep(): " << std::endl;
-  if(timeSlicedGeometry2->MSToTimeStep( 3.6 ) != 2)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-
-  std::cout << "Testing TimeSlicedGeometry::TimeStepToTimeStep(): " << std::endl;
-
-  // Re-use timeSlicedGeometry with new time bounds
-  mitk::TimeBounds timeBounds;
-  timeBounds[0] = 0.0;
-  timeBounds[1] = 1.0;
-  mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
-  geometry->Initialize();
-  geometry->SetTimeBounds( timeBounds );
-  timeSlicedGeometry->InitializeEvenlyTimed( geometry, numOfTimeSteps+1 );
-
-  if(timeSlicedGeometry2->TimeStepToTimeStep( timeSlicedGeometry, 4 ) != 2)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the TimeSlicedGeometry: ";
-  mitk::PlaneGeometry* accessedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(0));
-  if(accessedplanegeometry==NULL)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing identity of first geometry to the planegeometry in the TimeSlicedGeometry (should not be cloned): ";
-  if(accessedplanegeometry != planegeometry.GetPointer())
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing whether the spatial part of the first geometry in the TimeSlicedGeometry is identical to planegeometry by axis comparison and origin: "<<std::endl;
-  if((mitk::Equal(accessedplanegeometry->GetAxisVector(0), planegeometry->GetAxisVector(0))==false) ||
-     (mitk::Equal(accessedplanegeometry->GetAxisVector(1), planegeometry->GetAxisVector(1))==false) ||
-     (mitk::Equal(accessedplanegeometry->GetAxisVector(2), planegeometry->GetAxisVector(2))==false) ||
-     (mitk::Equal(accessedplanegeometry->GetOrigin(),      planegeometry->GetOrigin())==false))
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing timebounds of first geometry: "<<std::endl;
-  if( timeBounds1 != accessedplanegeometry->GetTimeBounds() )
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-
-
-  std::cout << "Testing availability and type (PlaneGeometry) of second geometry in the TimeSlicedGeometry: ";
-  mitk::PlaneGeometry* secondplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(1));
-  if(secondplanegeometry==NULL)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing PlaneGeometry::GetTimeBounds(): "<<std::endl;
-  const mitk::TimeBounds & secondtimebounds = secondplanegeometry->GetTimeBounds();
-  if( (timeBounds1[1] != secondtimebounds[0]) || (secondtimebounds[1] != secondtimebounds[0] + timeBounds1[1]-timeBounds1[0]) )
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-
-  std::cout << "Testing whether the spatial part of the second geometry in the TimeSlicedGeometry is identical to planegeometry by axis comparison and origin: "<<std::endl;
-  if((mitk::Equal(secondplanegeometry->GetAxisVector(0), planegeometry->GetAxisVector(0))==false) ||
-     (mitk::Equal(secondplanegeometry->GetAxisVector(1), planegeometry->GetAxisVector(1))==false) ||
-     (mitk::Equal(secondplanegeometry->GetAxisVector(2), planegeometry->GetAxisVector(2))==false) ||
-     (mitk::Equal(secondplanegeometry->GetOrigin(),      planegeometry->GetOrigin())==false))
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  // non-evenly-timed
-  std::cout << "Creating (new) TimeSlicedGeometry" <<std::endl;
-  timeSlicedGeometry2 = mitk::TimeSlicedGeometry::New();
-  if(timeSlicedGeometry2.IsNull())
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  numOfTimeSteps += 7;
-  std::cout << "Testing TimeSlicedGeometry::InitializeEmpty(timesteps = " << numOfTimeSteps << "): " <<std::endl;
-  timeSlicedGeometry2->InitializeEmpty(numOfTimeSteps);
-
-  std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed():" <<std::endl;
-  if(timeSlicedGeometry2->GetEvenlyTimed()!=false)
-  {
-    std::cout<<"[FAILED]"<<std::endl; ///\todo additionally test Initialize, default should be non-evenly-timed
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::SetEvenlyTimed(false):" <<std::endl;
-  timeSlicedGeometry2->SetEvenlyTimed(false);
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed()==false:" <<std::endl;
-  if(timeSlicedGeometry2->GetEvenlyTimed()!=false)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::GetTimeSteps()==" << numOfTimeSteps << ": " <<std::endl;
-  if(timeSlicedGeometry2->GetTimeSteps() != numOfTimeSteps)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing availability of first geometry in the TimeSlicedGeometry (should not exist): ";
-  mitk::Geometry3D* accessedgeometry = timeSlicedGeometry2->GetGeometry3D(0);
-  if(accessedgeometry!=NULL)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::SetGeometry3D(planegeometry, timesteps = 0): " <<std::endl;
-  timeSlicedGeometry2->SetGeometry3D(planegeometry, 0);
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the TimeSlicedGeometry: ";
-  accessedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(0));
-  if(accessedplanegeometry==NULL)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing identity of first geometry to the planegeometry in the TimeSlicedGeometry: ";
-  if(accessedplanegeometry != planegeometry.GetPointer())
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-
-
-  std::cout << "Testing availability of second geometry in the TimeSlicedGeometry (should not exist): ";
-  accessedgeometry = timeSlicedGeometry2->GetGeometry3D(1);
-  if(accessedgeometry!=NULL)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-
-  std::cout << "Setting planegeometry2 to a cloned version of planegeometry: "<<std::endl;
-  mitk::PlaneGeometry::Pointer planegeometry2;
-  planegeometry2 = dynamic_cast<mitk::PlaneGeometry*>(planegeometry->Clone().GetPointer());;
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Changing timebounds of planegeometry2: "<<std::endl;
-  mitk::TimeBounds timeBounds3;
-  timeBounds3[0] = timeBounds[1];
-  timeBounds3[1] = timeBounds3[0]+13.2334;
-  planegeometry2->SetTimeBounds(timeBounds3);
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing TimeSlicedGeometry::SetGeometry3D(planegeometry2, timesteps = 1): " <<std::endl;
-  timeSlicedGeometry2->SetGeometry3D(planegeometry2, 1);
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing availability and type (PlaneGeometry) of second geometry in the TimeSlicedGeometry: ";
-  accessedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(1));
-  if(accessedplanegeometry==NULL)
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing identity of second geometry to the planegeometry2 in the TimeSlicedGeometry: ";
-  if(accessedplanegeometry != planegeometry2.GetPointer())
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  std::cout << "Testing timebounds of second geometry: "<<std::endl;
-  if( timeBounds3 != accessedplanegeometry->GetTimeBounds() )
-  {
-    std::cout<<"[FAILED]"<<std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout<<"[PASSED]"<<std::endl;
-
-  // run additional tests to check the function ChangeImageGeometryConsideringOriginOffset(..)
-  mitkTimeSlicedGeometry_ChangeImageGeometryConsideringOriginOffset_Test();
-
-
-  std::cout<<"[TEST DONE]"<<std::endl;
-  return EXIT_SUCCESS;
-}
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index 37d254ccec..73f6320348 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,396 +1,399 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkLocalVariationImageFilter.h
   Algorithms/itkLocalVariationImageFilter.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/itkTotalVariationDenoisingImageFilter.h
   Algorithms/itkTotalVariationDenoisingImageFilter.txx
   Algorithms/itkTotalVariationSingleIterationImageFilter.h
   Algorithms/itkTotalVariationSingleIterationImageFilter.txx
   Algorithms/mitkBilateralFilter.h
   Algorithms/mitkBilateralFilter.cpp
   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/mitkExceptionMacro.h
   Common/mitkServiceBaseObject.h
   Common/mitkTestingMacros.h
   Common/mitkTesting.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/mitkImageToItk.txx
+  DataManagement/mitkTimeSlicedGeometry.h # Deprecated, empty for compatibilty reasons.
 
   Interactions/mitkEventMapperAddOn.h
 
   Interfaces/mitkIDataNodeReader.h
 
   Rendering/mitkLocalStorageHandler.h
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkCompareImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCoreActivator.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
-
+  DataManagement/mitkProportionalTimeGeometry.cpp
+  DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
 # DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataNodeFactory.cpp
 # DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkGeometry2D.cpp
   DataManagement/mitkGeometry2DData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkRestorePlanePositionOperation.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/mitkTimeSlicedGeometry.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/mitkShaderProperty.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
 
   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/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
 
   Interfaces/mitkInteractionEventObserver.cpp
   Interfaces/mitkIShaderRepository.cpp
   Interfaces/mitkIPropertyAliases.cpp
   Interfaces/mitkIPropertyDescriptions.cpp
   Interfaces/mitkIPropertyExtensions.cpp
   Interfaces/mitkIPropertyFilters.cpp
 
   IO/mitkBaseDataIOFactory.cpp
   IO/mitkCoreDataNodeReader.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileSeriesReader.cpp
   IO/mitkFileWriter.cpp
 # IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkImageWriter.cpp
   IO/mitkImageWriterFactory.cpp
   IO/mitkItkImageFileIOFactory.cpp
   IO/mitkItkImageFileReader.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkItkPictureWrite.cpp
   IO/mitkIOUtil.cpp
   IO/mitkLookupTableProperty.cpp
   IO/mitkOperation.cpp
 # IO/mitkPicFileIOFactory.cpp
 # IO/mitkPicFileReader.cpp
 # IO/mitkPicFileWriter.cpp
 # IO/mitkPicHelper.cpp
 # IO/mitkPicVolumeTimeSeriesIOFactory.cpp
 # IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetIOFactory.cpp
   IO/mitkPointSetReader.cpp
   IO/mitkPointSetWriter.cpp
   IO/mitkPointSetWriterFactory.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSTLFileIOFactory.cpp
   IO/mitkSTLFileReader.cpp
   IO/mitkSurfaceVtkWriter.cpp
   IO/mitkSurfaceVtkWriterFactory.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkVtiFileIOFactory.cpp
   IO/mitkVtiFileReader.cpp
   IO/mitkVtkImageIOFactory.cpp
   IO/mitkVtkImageReader.cpp
   IO/mitkVtkSurfaceIOFactory.cpp
   IO/mitkVtkSurfaceReader.cpp
   IO/vtkPointSetXMLParser.cpp
   IO/mitkLog.cpp
 
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkGeometry2DDataMapper2D.cpp
   Rendering/mitkGeometry2DDataVtkMapper3D.cpp
   Rendering/mitkGLMapper.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkPolyDataGLMapper2D.cpp
   Rendering/mitkSurfaceGLMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkShaderRepository.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
   Rendering/mitkRenderingTestHelper.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
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
   Common/mitkCoreServices.cpp
 )
 
 list(APPEND CPP_FILES ${CppMicroServices_SOURCES})
 
 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
 
 Shaders/mitkShaderLighting.xml
 
 mitkLevelWindowPresets.xml
 )
diff --git a/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox b/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox
index 1a6d25bf68..a84662807c 100644
--- a/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox
+++ b/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox
@@ -1,133 +1,123 @@
 namespace mitk{
 /**
 \page GeometryOverviewPage Geometry Overview
 
 Available sections:
 
 -# \ref GeometryOverviewPage_Introduction "Introduction to Geometries"
 -# \ref GeometryOverviewPage_Concept "The Geometry Concept"
 	-# \ref GeometryOverviewPage_Putting_Together "IMPORTANT: Putting it together for an Image"
 -# \ref GeometryOverviewPage_Connection "Connection between MITK, ITK and VTK Geometries"\n\n
 
 \section GeometryOverviewPage_Introduction Introduction to Geometries
 
 Geometries are used to describe the geometrical properties of data objects in space and time.\n
 To use the geometry classes in the right way you have to understand the three different coordinate types present in MITK:\n\n
 \image html CoordinateTypes.png
 <center><b>The different coordinate types\n\n</b></center>\n
 	-# World coordinates:
 	    	- World coordinates are describing the actual spacial position of all MITK objects regarding a global coordinate system, normally specified by the imaging modality 
 		- The geometry defines the offset, orientation, and scale of the considered data objects in reference to the world coordinate systems.
 		- World coordinates are always measured in mm
 		- If you are dealing with an image geometry, the origin of an image is pointing to the CENTER of the bottom-left-back voxel.\n 
 		- If you are NOT dealing with an image geometry (no defined discrete Voxels), the origin is pointing to the bottom-left-back CORNER
 		- Index coordinates can be converted to world coordinates by calling Geometry3D::IndexToWorld()\n\n
 
 \image html worldcoordinateSystem.png
 <center><b>Corner-based coordinates\n\n</b></center>
 \image html WorldcoordinateSystemCenterBased.png
 <center><b>Center-based image-coordinates\n\n</b></center>\n
 	-# Continuous index coordinates:
 		- Dividing world coordinates through the pixel spacing and simultanously taking the offset into account leads to continuous index coordinates inside your dataobject.\n
 		  So continuous coordinates can be float values!
 		- They can be obtained by calling Geometry3D::WorldToIndex(), where &pt_mm is a point in worldcoordinates.\n 		
 	-# Index coordinate system:
 		- Index coordinates are discrete values that address voxels of a data object explicitly.
 		- Basically they are continuous index coordinates which are rounded from half integer up.
 		- E.g. (0,0) specifies the very first pixel of a 2D image, (0,1) the pixel of the next column in the same row
 		- If you have world coordinates, they can be converted to discrete index coordinates by calling
           Geometry3D::WorldToIndex()\n\n  
 
 \section GeometryOverviewPage_Concept The Geometry Concept
 
 As the superclass of all MITK geometries Geometry3D holds:
 	- a spacial bounding box which is axes-parallel in index coordinates (often discrete indices of pixels), to be accessed by Geometry3D::GetBoundingBox()
 	- a time related bounding box which holds the temporal validity of the considered data object in milliseconds (start and end time), to be accessed by Geometry3D::GetTimeBounds().\n 
 	  The default for 3D geometries is minus infinity to plus infinity, meaning the object is always displayed independent of displayed time in MITK.
 	- position information in form of a Euclidean transform in respect to world coordinates (i.e. a linear transformation matrix and offset) to convert (discrete or continuous) index coordinates to world coordinates and vice versa,\n
        to be accessed by Geometry3D::GetIndexToWorldTransform()\n
 	   See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries"
 	- Many other properties (e.g. origin, extent, ...) which can be found in the \ref Geometry3D "class documentation"
 	- <b> VERY IMPORTANT:</b>\n A flag called <i>isImageGeometry</i>, which indicates whether the coordinates are center-based or not!\n 
 	  See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries" and \ref GeometryOverviewPage_Putting_Together "IMPORTANT: Putting it together for an Image"\n\n	
 
-Every data object which is (sub-)class of BaseData has a Geometry3D, to be more specific, a TimeSlicedGeometry, to be accessed by BaseData::GetTimeSlicedGeometry().\n 
-This is because all data objects are objects in space and time. The data values are often stored in index coordinates, e.g., integer pixel/voxel or time indices.\n 
-The information required to convert these index coordinates into a world coordinate system, with spatiotemporal coordinates in millimeters and milliseconds, is stored in Geometry3D\n
-class and its sub-classes.
 
-TimeSlicedGeometry describes a spatiotemporal geometry consisting of spatial geometries existing at different times, and allocates each geometry at a valid time step a discrete number. It contains a list of Geometry3D instances to be accessed by\n
-TimeSlicedGeometry::GetGeometry3D(t), with t between 0 and TimeSlicedGeometry::GetTimeSteps().\n
-To convert between world time in milliseconds and the integer timestep number use TimeSlicedGeometry::MSToTimeStep(), for conversion in the opposite direction\n
-TimeSlicedGeometry::TimeStepToMS().
+Every data object (sub-)class of BaseData has a TimeGeometry which is accessed by BaseData::GetTimeGeometry(). This TimeGeometry holds one or more Geometry3D objects which describes the object at specific time points, e.g. provides conversion between world and index coordinates and contains bounding boxes covering the area in which the data are placed. There is the possibility of using different implementations of the abstract TimeGeometry class which may differ in how the time steps are saved and the times are calculated.
 
-Often all Geometry3D instances contained in a TimeSlicedGeometry have the same temporal extent.\n
-The initialization for this case can be done using TimeSlicedGeometry::InitializeEvenlyTimed(Geometry3D *geometry3D, unsigned int timeSteps). 
-The Geometry3D parameter must have a limited life span set by Geometry3D::SetTimeBounds(). It is used as the first Geometry3D contained in the TimeSlicedGeometry (thus returned by TimeSlicedGeometry:: GetGeometry3D(0)). 
-The next one will start to have a valid time range immediately at the end of validness of the processor. The bounding boxes and spacial transformations are copied.\n
-The instance of Geometry3D provided to TimeSlicedGeometry::InitializeEvenlyTimed is referenced, not copied!
+There are two ways to represent a time, either by a TimePointType or a TimeStepType. The first is similar to the continous index coordinates and defines a Time Point in milliseconds from timepoint zero. The second type is similar to index coordinates. These are discrete values which specify the number of the current time step going from 0 to GetNumberOfTimeSteps(). The conversion between a time point and a time step is done by calling the method TimeGeometry::TimeStepToTimePoint() or TimeGeometry::TimePointToTimeStep(). Note that the duration of a time step may differ from object to object, so in general it is better to calculate the corresponding time steps by using time points. Also the distance of the time steps does not need to be equidistant over time, it depends on the used TimeGeometry implementation. 
 
-TimeSlicedGeometry is a Geometry3D itself. Its bounding box and transformation is usually the same as the bounding box and transformations of the contained Geometry3D instances.\n 
-Its life span (to be accessed by TimeSlicedGeometry::GetTimeBounds()) is the span from the initial valid time of the first contained Geometry3D to the termination of the last valid time of contained Geometry3Ds.
+Each TimeGeometry has a bounding box covering the whole area in which the corresponding object is situated during all time steps. This bounding box may be accessed by calling TimeGeometry::GetBoundingBoxInWorld() and is always in world coordinates. The bounding box is calculated from all time steps, to manually start this calculation process call TimeGeometry::Update().  The bounding box is not updated if the getter is called. 
 
-TimeSlicedGeometry can also contain Geometry3D instances that do not have the same Euclidean geometry. In that case, TimeSlicedGeometry::GetEvenlyTimed() has to be false.
+The TimeGeometry does not provide a transformation of world coordinates into image coordinates since each time step may has a different transformation. If a conversion between image and world is needed, the Geometry3D for a specific time step or time point must be fetched either by TimeGeometry::GetGeometryForTimeStep() or TimeGeometry::GetGeometryForTimePoint() and then the conversion is calculated by using this geometry. 
+
+The TimeGeometry class is an abstract class therefore it is not possible to instantiate it. instead a derived class must be used. Currently the only class that can be chosen is ProportionalTimeGeometry() which assumes that the time steps are ordered equidistant. To initialize an object with given geometries call ProportionalTimeGeometry::Initialize() with an existing Geometry3D and the number of time steps. The given geometries will be copied and not referenced!
 
 SlicedGeometry3D is a sub-class of Geometry3D, which describes data objects consisting of slices, e.g., objects of type Image (or SlicedData, which is the super-class of Image). 
-Therefore, Image::GetTimeSlicedGeometry() will contain a list of SlicedGeometry3D instances. There is a special method SlicedData::GetSlicedGeometry(t) which directly returns\n
+Therefore, Image::GetTimeGeometry() will contain a list of SlicedGeometry3D instances. There is a special method SlicedData::GetSlicedGeometry(t) which directly returns\n
 a SlicedGeometry3D to avoid the need of casting.
 
-Comparable to TimeSlicedGeometry the class SlicedGeometry3D contains a list of Geometry2D objects describing the slices in the image. Instead of time steps we have spatial steps here from 0 to GetSlices(). 
+The class SlicedGeometry3D contains a list of Geometry2D objects describing the slices in the image.We have here spatial steps from 0 to GetSlices(). 
 SlicedGeometry3D::InitializeEvenlySpaced (Geometry2D *geometry2D, unsigned int slices) initializes a stack of slices with the same thickness, one starting at the position where the previous one ends.
 
 Geometry2D provides methods for working with 2D manifolds (i.e., simply spoken, an object that can be described using a 2D coordinate-system) in 3D space.\n
 For example it allows mapping of a 3D point on the 2D manifold using Geometry2D::Map(). A subclass of Geometry2D called PlaneGeometry, explicitly describes a 2D rectangular plane.\n
 Another important subclass of Geometry2D is the DisplayGeometry which describes the geometry of the display (the monitor screen). Basically it represents a rectangular view on a 2D world geometry\n
 The DisplayGeometry converts between screen and world coordinates, processes input events (e.g. mouse click) and provides methods for zooming and panning.\n
 \image html DisplayGeometry.png
 <center><b>Display Geometry\n\n</b></center>
 Finally there is the AbstractTransformGeometry which describes a 2D manifold in 3D space, defined by a vtkAbstractTransform. It is a abstract superclass for arbitrary user defined geometries\n
 An example is the ThinPlateSplineCurvedGeometry.\n
 
 \subsection GeometryOverviewPage_Putting_Together IMPORTANT: Putting it together for an Image
 
 Please read this section accurately if you are working with Images!
 
 The definition of the position of the corners of an image is different than the one of other data objects:
 
 As mentioned in the previous section, world coordinates of data objects (e.g. surfaces ) usually specify the bottom left back corner of an object.
 
 In contrast to that a geometry of an Image is center-based, which means that the world coordinates of a voxel belonging to an image points to the center of that voxel. 
 E.g:
 
 \image html PixelCenterBased.png
 <center><b>Center-based voxel\n\n</b></center>
 
 If the origin of e.g. a surface lies at (15,10,0) in world coordinates, the origin`s world coordinates for an image are internally calculated like the following:
 
 										<center>(15-0.5*X-Spacing\n
 										 10-0.5*Y-Spacing\n
 										   0-0.5*Z-Spacing)\n</center>
 										  
 If the image`s spacing is (x,y,z)=(1,1,3) then the corner coordinates are (14.5,9.5,-1.5).
 
 <b>If your geometry describes an image, the member variable <i>isImageGeometry</i> must be changed to true. This variable indicates also if your geometry is center-based or not.\n 
 The change can be done in two ways:\n
 	-#	You are sure that your origin is already center-based. Whether because you adjusted it manually or you copied it from another image.\n
 	    In that case, you can call the function <i>setImageGeometry(true)</i> or <i>imageGeometryOn()</i> to set the bool variable to true.
  	-#	You created a new geometry, did not manually adjust the origin to be center-based and have the bool value isImageGeometry set to false (default).\n 
  	    In that case, call the function  <i>ChangeImageGeometryConsideringOriginOffset(true)</i>. It will adjust your origin automatically and set the bool flag to true.\n
 
 If you experience displaced contours, figures or other stuff, it is an indicator that you have not considered the origin offset mentioned above.</b>\n\n
 
-An image has a TimeSlicedGeometry, which contains one or more SlicedGeometry3D instances (one for each time step), all of which contain one or more instances of (sub-classes of) Geometry2D (usually PlaneGeometry).\n
+An image has a TimeGeometry, which contains one or more SlicedGeometry3D instances (one for each time step), all of which contain one or more instances of (sub-classes of) Geometry2D (usually PlaneGeometry).\n
 As a reminder: Geometry instances referring to images need a slightly different definition of corners, see Geometry3D::SetImageGeometry. This is usualy automatically called by Image.\n\n
 
 \section GeometryOverviewPage_Connection Connection between MITK, ITK and VTK Geometries
 \image html ITK_VTK_MITK_Geometries.png
 \n\n
 	- VTK transformation for rendering
 	- ITK transformation for calculations
 	- Both automatically updated when one is changed\n
 Attention:<b>Not</b> automatically updated when changed hardcoded. Example: geometry->GetVtkMatrix()->Rotate(....)
 */
 }
\ No newline at end of file
diff --git a/Core/Documentation/Doxygen/Groups/ModuleGeometry.dox b/Core/Documentation/Doxygen/Groups/ModuleGeometry.dox
index 988a18d3b3..e916e59570 100644
--- a/Core/Documentation/Doxygen/Groups/ModuleGeometry.dox
+++ b/Core/Documentation/Doxygen/Groups/ModuleGeometry.dox
@@ -1,47 +1,46 @@
 namespace mitk
 {
 /**
 \defgroup Geometry Geometry Classes
 \ingroup Core
 
 \brief This subcategory includes the geometry classes, which describe the geometry of the
 data in space and time.
 
 The Geometry3D class holds (see figure)
 \li a bounding box which is axes-parallel in intrinsic coordinates (often integer indices of pixels), to be accessed by Geometry3D::GetBoundingBox()
 \li a transform to convert intrinsic coordinates into a world-coordinate system with coordinates in millimeters and milliseconds (floating point values), to be accessed by Geometry3D::GetIndexToWorldTransform()
 \li a life span, i.e. a bounding box in time in ms (with start and end time), to be accessed by Geometry3D::GetTimeBounds(). The default is minus infinity to plus infinity.
 
 \image html ModuleGeometryFig1.png "Geometry: Bounding box and transform"
 
 Geometry3D and its sub-classes allow converting between intrinsic coordinates (called index or unit coordinates) and word-coordinates (called world or mm coordinates), e.g. Geometry3D::WorldToIndex.
 
-Every data object (sub-)class of BaseData has a Geometry3D, to be more specific, a TimeSlicedGeometry, to be accessed by BaseData::Get TimeSlicedGeometry(). This is because data objects are objects in space and time. The data values are often stored in intrinsic coordinates, e.g., integer pixel/voxel or time indices. The information required to convert these intrinsic coordinates into a physical world coordinate system, with coordinates in millimeters and milliseconds, is stored in Geometry3D class and its sub-classes.
+Every data object (sub-)class of BaseData has a TimeGeometry which is accessed by BaseData::GetTimeGeometry(). This TimeGeometry holds one or more Geometry3D objects which describes the object at specific time points, e.g. provides conversion between world and index coordinates and contains bounding boxes covering the area in which the data are placed. There is the possibility of using different implementations of the abstract TimeGeometry class which may differ in how the time steps are saved and the times are calculated.
 
-TimeSlicedGeometry describes a geometry consisting of several geometries which exist at different times. It contains a list of Geometry3D instances to be accessed by TimeSlicedGeometry::GetGeometry3D(t), with t between 0 and TimeSlicedGeometry::GetTimeSteps().To convert between world-time in milliseconds and the integer timestep-number use mitk:TimeSlicedGeometry:: MSToTimeStep, for conversion in the opposite direction mitk:TimeSlicedGeometry:: TimeStepToMS.
+There are two ways to represent a time, either by a TimePointType or a TimeStepType. The first is similar to the continous index coordinates and defines a Time Point in milliseconds from timepoint zero. The second type is similar to index coordinates. These are discrete values which specify the number of the current time step going from 0 to GetNumberOfTimeSteps(). The conversion between a time point and a time step is done by calling the method TimeGeometry::TimeStepToTimePoint() or TimeGeometry::TimePointToTimeStep(). Note that the duration of a time step may differ from object to object, so in general it is better to calculate the corresponding time steps by using time points. Also the distance of the time steps does not need to be equidistant over time, it depends on the used TimeGeometry implementation. 
 
-Often all Geometry3D instances contained in a TimeSlicedGeometry have the same duration of life. The initialization for this case can be done using TimeSlicedGeometry::InitializeEvenlyTimed(Geometry3D *geometry3D, unsigned int timeSteps). The Geometry3D parameter must have a limited life span set by Geometry3D::SetTimeBounds(). It is used as the first Geometry3D contained in the TimeSlicedGeometry (thus returned by TimeSlicedGeometry:: GetGeometry3D(0)). The next one will start to live immediately at the end of life of the first. The bounding boxes and transformations are copied. The instance of Geometry3D provided to TimeSlicedGeometry::InitializeEvenlyTimed is referenced, not copied!
+Each TimeGeometry has a bounding box covering the whole area in which the corresponding object is situated during all time steps. This bounding box may be accessed by calling TimeGeometry::GetBoundingBoxInWorld() and is always in world coordinates. The bounding box is calculated from all time steps, to manually start this calculation process call TimeGeometry::Update().  The bounding box is not updated if the getter is called. 
 
-TimeSlicedGeometry is a Geometry3D itself. Its bounding box and transformation is usually the same as the bounding box and transformations of the contained Geometry3D instances.  Its life span (to be accessed by TimeSlicedGeometry::GetTimeBounds()) is the span from the beginning of the first contained Geometry3D to the end of the last contained Geometry3D.
+The TimeGeometry does not provide a transformation of world coordinates into image coordinates since each time step may has a different transformation. If a conversion between image and world is needed, the Geometry3D for a specific time step or time point must be fetched either by TimeGeometry::GetGeometryForTimeStep() or TimeGeometry::GetGeometryForTimePoint() and then the conversion is calculated by using this geometry. 
 
-TimeSlicedGeometry can also contain Geometry3D instances that do not have the same bounding box and transformation. In this case, TimeSlicedGeometry::GetEvenlyTimed() has to be \a false.
+The TimeGeometry class is an abstract class therefore it is not possible to instantiate it. instead a derived class must be used. Currently the only class that can be chosen is ProportionalTimeGeometry() which assumes that the time steps are ordered equidistant. To initialize an object with given geometries call ProportionalTimeGeometry::Initialize() with an existing Geometry3D and the number of time steps. The given geometries will be copied and not referenced!
 
-SlicedGeometry3D is a sub-class of Geometry3D, which descibes data objects consisting of slices, e.g., objects of type Image (or SlicedData, which is the super-class of Image). Therefore, Image::Get TimeSlicedGeometry() will contain a list of SlicedGeometry3D instances. There is a special method
-SlicedData::GetSlicedGeometry(t) which directly returns a SlicedGeometry3D to avoid the need of casting.
+For each time step of a given object a geometry-object needs to be specified. This are Geometry3D objects of objects of classes which are derived from Geometry3D. For example, images uses the sub-class SlicedGeometry, which contains several Geometry2D objects.
 
 Geometry instances referring to images need a slightly different definition of corners, see Geometry3D::SetImageGeometry. This is usualy automatically called by Image.
 
-Comparable to TimeSlicedGeometry the class SlicedGeometry3D contains a list of Geometry2D objects describing the slices in the data object. Instead of time steps we have spatial steps here from 0 to GetSlices(). SlicedGeometry3D::InitializeEvenlySpaced (Geometry2D *geometry2D, unsigned int slices) initializes a stack of slices with the same thickness, one starting at the position where the previous one ends.
+The class SlicedGeometry3D contains a list of Geometry2D objects describing the slices in the data object. It has spatial steps from 0 to GetSlices(). SlicedGeometry3D::InitializeEvenlySpaced (Geometry2D *geometry2D, unsigned int slices) initializes a stack of slices with the same thickness, one starting at the position where the previous one ends.
 
 Geometry2D provides methods for working with 2D manifolds (i.e., simply spoken, an object that can be described using a 2D coordinate-system) in 3D space. For example it allows mapping a 3D point on the 2D manifold using Geometry2D::Map. The most important sub-class is PlaneGeometry2D, which describes a planar rectangle.
 
 \section ExampleForImage Putting it together for Image
 
-Image has a TimeSlicedGeometry, which contains one or more SlicedGeometry3D instances (one for each time step), all of which contain one or more instances of (sub-classes of) Geometry2D (usually PlaneGeometry2D).
+Image has a TimeGeometry, which contains one or more SlicedGeometry3D instances (one for each time step), all of which contain one or more instances of (sub-classes of) Geometry2D (usually PlaneGeometry2D).
 
 \deprecated For ITK rev. 3.8 and earlier: Converting coordinates from the ITK physical coordinate system (which did not support rotated images for ITK v3.8 and earlier) to the MITK world coordinate system should be performed via the Geometry3D of the Image, see Geometry3D::WorldToItkPhysicalPoint.
 
 As a reminder: Geometry instances referring to images need a slightly different definition of corners, see Geometry3D::SetImageGeometry. This is usualy automatically called by Image.
 */
 //\f$-\infty\f$ to \f$+\infty\f$.
 }
diff --git a/Examples/QtAppExample/Step1.cpp b/Examples/QtAppExample/Step1.cpp
index b488892a2f..4172a82295 100644
--- a/Examples/QtAppExample/Step1.cpp
+++ b/Examples/QtAppExample/Step1.cpp
@@ -1,107 +1,107 @@
 /*===================================================================
 
 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 "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 
 #include <mitkDataNodeFactory.h>
 #include <mitkStandaloneDataStorage.h>
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 
 // Load image (nrrd format) and display it in a 2D view
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if (argc < 2)
   {
     fprintf( stderr, "Usage:   %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   // The DataStorage manages all data objects. It is used by the
   // rendering mechanism to render all data objects
   // We use the standard implementation mitk::StandaloneDataStorage.
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
 
   //*************************************************************************
   // Part II: Create some data by reading a file
   //*************************************************************************
 
   // Create a DataNodeFactory to read a data format supported
   // by the DataNodeFactory (many image formats, surface formats, etc.)
   mitk::DataNodeFactory::Pointer reader=mitk::DataNodeFactory::New();
   const char * filename = argv[1];
   try
   {
     reader->SetFileName(filename);
     reader->Update();
     //*************************************************************************
     // Part III: Put the data into the datastorage
     //*************************************************************************
 
     // Add the node to the DataStorage
     ds->Add(reader->GetOutput());
   }
   catch(...)
   {
     fprintf( stderr, "Could not open file %s \n\n", filename );
     exit(2);
   }
 
   //*************************************************************************
   // Part IV: Create window and pass the datastorage to it
   //*************************************************************************
 
   // Create a RenderWindow
   QmitkRenderWindow renderWindow;
 
   // Tell the RenderWindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Initialize the RenderWindow
-  mitk::TimeSlicedGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
+  mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews( geo );
   //mitk::RenderingManager::GetInstance()->InitializeViews();
 
   // Select a slice
   mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
   if (sliceNaviController)
     sliceNaviController->GetSlice()->SetPos( 0 );
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   renderWindow.show();
   renderWindow.resize( 256, 256 );
 
   qtapplication.exec();
 
   // cleanup: Remove References to DataStorage. This will delete the object
   ds = NULL;
 }
 
diff --git a/Examples/QtFreeRender/QtFreeRender.cpp b/Examples/QtFreeRender/QtFreeRender.cpp
index 70dc014e96..773a10b531 100644
--- a/Examples/QtFreeRender/QtFreeRender.cpp
+++ b/Examples/QtFreeRender/QtFreeRender.cpp
@@ -1,373 +1,373 @@
 /*===================================================================
 
  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 "mitkRenderWindow.h"
 
 #include <mitkDataNodeFactory.h>
 #include <mitkStandaloneDataStorage.h>
 #include <mitkProperties.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkRenderingManager.h>
 #include <mitkGlobalInteraction.h>
 #include "mitkProperties.h"
 #include "mitkGeometry2DDataMapper2D.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkLine.h"
 #include "mitkInteractionConst.h"
 #include "mitkVtkLayerController.h"
 #include "mitkPositionTracker.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkSlicesRotator.h"
 #include "mitkSlicesSwiveller.h"
 #include "mitkRenderWindowFrame.h"
 #include "mitkGradientBackground.h"
 #include "mitkCoordinateSupplier.h"
 #include "mitkDataStorage.h"
 
 #include "vtkTextProperty.h"
 #include "vtkCornerAnnotation.h"
 #include "vtkRenderWindow.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkAnnotatedCubeActor.h"
 #include "vtkOrientationMarkerWidget.h"
 #include "vtkProperty.h"
 
 // us
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 
 #include "mitkInteractionEventObserver.h"
 
 //##Documentation
 //## @brief Example of a NON QT DEPENDENT MITK RENDERING APPLICATION.
 
 mitk::RenderWindow::Pointer mitkWidget1;
 mitk::RenderWindow::Pointer mitkWidget2;
 mitk::RenderWindow::Pointer mitkWidget3;
 mitk::RenderWindow::Pointer mitkWidget4;
 
 mitk::DisplayInteractor::Pointer m_DisplayInteractor;
 mitk::CoordinateSupplier::Pointer m_LastLeftClickPositionSupplier;
 mitk::GradientBackground::Pointer m_GradientBackground4;
 mitk::RenderWindowFrame::Pointer m_RectangleRendering1;
 mitk::RenderWindowFrame::Pointer m_RectangleRendering2;
 mitk::RenderWindowFrame::Pointer m_RectangleRendering3;
 mitk::RenderWindowFrame::Pointer m_RectangleRendering4;
 
 mitk::SliceNavigationController* m_TimeNavigationController = NULL;
 
 mitk::DataStorage::Pointer m_DataStorage;
 mitk::DataNode::Pointer m_PlaneNode1;
 mitk::DataNode::Pointer m_PlaneNode2;
 mitk::DataNode::Pointer m_PlaneNode3;
 mitk::DataNode::Pointer m_Node;
 
 void InitializeWindows()
 {
 
   // 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);
 
   //initialize m_TimeNavigationController: send time via sliceNavigationControllers
   m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
   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->GetVtkRenderWindow()));
 
   //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);
 
   // Let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
   gi->AddListener(m_TimeNavigationController);
 
   m_LastLeftClickPositionSupplier = mitk::CoordinateSupplier::New("navigation", NULL);
   mitk::GlobalInteraction::GetInstance()->AddListener(m_LastLeftClickPositionSupplier);
 
   m_GradientBackground4 = mitk::GradientBackground::New();
   m_GradientBackground4->SetRenderWindow(mitkWidget4->GetVtkRenderWindow());
   m_GradientBackground4->SetGradientColors(0.1, 0.1, 0.1, 0.5, 0.5, 0.5);
   m_GradientBackground4->Enable();
 
   m_RectangleRendering1 = mitk::RenderWindowFrame::New();
   m_RectangleRendering1->SetRenderWindow(mitkWidget1->GetVtkRenderWindow());
   m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
 
   m_RectangleRendering2 = mitk::RenderWindowFrame::New();
   m_RectangleRendering2->SetRenderWindow(mitkWidget2->GetVtkRenderWindow());
   m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
 
   m_RectangleRendering3 = mitk::RenderWindowFrame::New();
   m_RectangleRendering3->SetRenderWindow(mitkWidget3->GetVtkRenderWindow());
   m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
 
   m_RectangleRendering4 = mitk::RenderWindowFrame::New();
   m_RectangleRendering4->SetRenderWindow(mitkWidget4->GetVtkRenderWindow());
   m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
 
 }
 
 void 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::IntProperty::Pointer layer = mitk::IntProperty::New(1000);
 
   // ... of widget 1
   m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
   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));
   m_PlaneNode1->SetProperty("layer", layer);
   m_PlaneNode1->SetColor(1.0, 0.0, 0.0);
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   m_PlaneNode2 = (mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
   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));
   m_PlaneNode2->SetProperty("layer", layer);
   m_PlaneNode2->SetColor(0.0, 1.0, 0.0);
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
   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));
   m_PlaneNode3->SetProperty("layer", layer);
   m_PlaneNode3->SetColor(0.0, 0.0, 1.0);
   mapper = mitk::Geometry2DDataMapper2D::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));
 
   //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);
     }
   }
 }
 
 void Fit()
 {
   vtkRenderer * vtkrenderer;
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != NULL)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != NULL)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != NULL)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != NULL)
     vtkrenderer->ResetCamera();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 int main(int argc, char* argv[])
 {
   if (argc < 2)
   {
     fprintf(stderr, "Usage:   %s [filename1] [filename2] ...\n\n", "");
     return 1;
   }
 
   // Create a DataStorage
   m_DataStorage = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for (i = 1; i < argc; ++i)
   {
     // For testing
     if (strcmp(argv[i], "-testing") == 0)
       continue;
 
     // Create a DataNodeFactory to read a data format supported
     // by the DataNodeFactory (many image formats, surface formats, etc.)
     mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
     const char * filename = argv[i];
     try
     {
       nodeReader->SetFileName(filename);
       nodeReader->Update();
 
       // Since the DataNodeFactory directly creates a node,
       // use the datastorage to add the read node
       mitk::DataNode::Pointer node = nodeReader->GetOutput();
       m_DataStorage->Add(node);
 
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
       if (image.IsNotNull())
       {
         // Set the property "volumerendering" to the Boolean value "true"
         node->SetProperty("volumerendering", mitk::BoolProperty::New(false));
         node->SetProperty("name", mitk::StringProperty::New("testimage"));
         node->SetProperty("layer", mitk::IntProperty::New(1));
       }
     } catch (...)
     {
       fprintf(stderr, "Could not open file %s \n\n", filename);
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part V: Create window and pass the tree to it
   //*************************************************************************
 
   // Global Interaction initialize
   // legacy because window manager relies still on existence if global interaction
   mitk::GlobalInteraction::GetInstance()->Initialize("global");
 
   //mitk::GlobalInteraction::GetInstance()->AddListener(m_DisplayInteractor);
 
   // Create renderwindows
   mitkWidget1 = mitk::RenderWindow::New();
   mitkWidget2 = mitk::RenderWindow::New();
   mitkWidget3 = mitk::RenderWindow::New();
   mitkWidget4 = mitk::RenderWindow::New();
 
   // Tell the renderwindow which (part of) the datastorage to render
   mitkWidget1->GetRenderer()->SetDataStorage(m_DataStorage);
   mitkWidget2->GetRenderer()->SetDataStorage(m_DataStorage);
   mitkWidget3->GetRenderer()->SetDataStorage(m_DataStorage);
   mitkWidget4->GetRenderer()->SetDataStorage(m_DataStorage);
 
   // Let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
   gi->AddListener(mitkWidget1->GetSliceNavigationController());
   gi->AddListener(mitkWidget2->GetSliceNavigationController());
   gi->AddListener(mitkWidget3->GetSliceNavigationController());
   gi->AddListener(mitkWidget4->GetSliceNavigationController());
 
   // instantiate display interactor
   if (m_DisplayInteractor.IsNull())
   {
     m_DisplayInteractor = mitk::DisplayInteractor::New();
     m_DisplayInteractor->LoadStateMachine("DisplayInteraction.xml");
     m_DisplayInteractor->SetEventConfig("DisplayConfigMITK.xml");
     // Register as listener via micro services
 
     us::ModuleContext* context = us::GetModuleContext();
     context->RegisterService<mitk::InteractionEventObserver>(
         m_DisplayInteractor.GetPointer());
   }
   // Use it as a 2D View
   mitkWidget1->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
   mitkWidget2->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
   mitkWidget3->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
   mitkWidget4->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   mitkWidget1->SetSize(400, 400);
 
   mitkWidget2->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
       mitkWidget1->GetVtkRenderWindow()->GetPosition()[1]);
   mitkWidget2->SetSize(400, 400);
 
   mitkWidget3->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0],
       mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
   mitkWidget3->SetSize(400, 400);
 
   mitkWidget4->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
       mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
   mitkWidget4->SetSize(400, 400);
 
   InitializeWindows();
 
   AddDisplayPlaneSubTree();
 
   Fit();
 
   // Initialize the RenderWindows
-  mitk::TimeSlicedGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
+  mitk::TimeGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
   m_DataStorage->Print(std::cout);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // reinit the mitkVTKEventProvider;
   // this is only necessary once after calling
   // ForceImmediateUpdateAll() for the first time
   mitkWidget1->ReinitEventProvider();
   mitkWidget2->ReinitEventProvider();
   mitkWidget3->ReinitEventProvider();
 
   mitkWidget1->GetVtkRenderWindow()->Render();
   mitkWidget2->GetVtkRenderWindow()->Render();
   mitkWidget3->GetVtkRenderWindow()->Render();
   mitkWidget4->GetVtkRenderWindow()->Render();
   mitkWidget4->GetVtkRenderWindowInteractor()->Start();
 
   return 0;
 }
 
diff --git a/Examples/Tutorial/Step1.cpp b/Examples/Tutorial/Step1.cpp
index 836be5912d..140bd8a6f5 100644
--- a/Examples/Tutorial/Step1.cpp
+++ b/Examples/Tutorial/Step1.cpp
@@ -1,115 +1,115 @@
 /*===================================================================
 
 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 "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 
 #include <mitkDataNodeFactory.h>
 #include <mitkStandaloneDataStorage.h>
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 
 //##Documentation
 //## @brief Load image (nrrd format) and display it in a 2D view
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if (argc < 2)
   {
     fprintf( stderr, "Usage:   %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   // The DataStorage manages all data objects. It is used by the
   // rendering mechanism to render all data objects
   // We use the standard implementation mitk::StandaloneDataStorage.
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
 
   //*************************************************************************
   // Part II: Create some data by reading a file
   //*************************************************************************
 
   // Create a DataNodeFactory to read a data format supported
   // by the DataNodeFactory (many image formats, surface formats, etc.)
   mitk::DataNodeFactory::Pointer reader=mitk::DataNodeFactory::New();
   const char * filename = argv[1];
   try
   {
     reader->SetFileName(filename);
     reader->Update();
     //*************************************************************************
     // Part III: Put the data into the datastorage
     //*************************************************************************
 
     // Add the node to the DataStorage
     ds->Add(reader->GetOutput());
   }
   catch(...)
   {
     fprintf( stderr, "Could not open file %s \n\n", filename );
     exit(2);
   }
 
   //*************************************************************************
   // Part IV: Create window and pass the datastorage to it
   //*************************************************************************
 
   // Create a RenderWindow
   QmitkRenderWindow renderWindow;
 
   // Tell the RenderWindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Initialize the RenderWindow
-  mitk::TimeSlicedGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
+  mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews( geo );
   //mitk::RenderingManager::GetInstance()->InitializeViews();
 
   // Select a slice
   mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
   if (sliceNaviController)
     sliceNaviController->GetSlice()->SetPos( 0 );
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   renderWindow.show();
   renderWindow.resize( 256, 256 );
 
   // for testing
   #include "QtTesting.h"
   if (strcmp(argv[argc-1], "-testing") != 0)
     return qtapplication.exec();
   else
     return QtTesting();
 
   // cleanup: Remove References to DataStorage. This will delete the object
   ds = NULL;
 }
 /**
 \example Step1.cpp
 */
diff --git a/Examples/Tutorial/Step2.cpp b/Examples/Tutorial/Step2.cpp
index a01d21dd0e..94dc282bb5 100644
--- a/Examples/Tutorial/Step2.cpp
+++ b/Examples/Tutorial/Step2.cpp
@@ -1,118 +1,118 @@
 /*===================================================================
 
 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 "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 
 #include <mitkDataNodeFactory.h>
 #include <mitkStandaloneDataStorage.h>
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 
 //##Documentation
 //## @brief Load one or more data sets (many image, surface
 //## and other formats) and display it in a 2D view
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if(argc<2)
   {
     fprintf( stderr, "Usage:   %s [filename1] [filename2] ...\n\n",
       itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a data storage object. We will use it as a singleton
   mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for(i=1; i<argc; ++i)
   {
     // For testing
     if(strcmp(argv[i], "-testing")==0) continue;
 
     // Create a DataNodeFactory to read a data format supported
     // by the DataNodeFactory (many image formats, surface formats, etc.)
     mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
     const char * filename = argv[i];
     try
     {
       nodeReader->SetFileName(filename);
       nodeReader->Update();
       //*********************************************************************
       // Part III: Put the data into the datastorage
       //*********************************************************************
 
       // Since the DataNodeFactory directly creates a node,
       // use the datastorage to add the read node
       storage->Add(nodeReader->GetOutput());
     }
     catch(...)
     {
       fprintf( stderr, "Could not open file %s \n\n", filename );
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part IV: Create window and pass the datastorage to it
   //*************************************************************************
 
   // Create a RenderWindow
   QmitkRenderWindow renderWindow;
 
   // Tell the RenderWindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(storage);
 
   // Initialize the RenderWindow
-  mitk::TimeSlicedGeometry::Pointer geo = storage->ComputeBoundingGeometry3D(storage->GetAll());
+  mitk::TimeGeometry::Pointer geo = storage->ComputeBoundingGeometry3D(storage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews( geo );
 
   // Select a slice
   mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
   if (sliceNaviController)
     sliceNaviController->GetSlice()->SetPos( 2 );
 
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   renderWindow.show();
   renderWindow.resize( 256, 256 );
 
   // for testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 
 /**
 \example Step2.cpp
 */
diff --git a/Examples/Tutorial/Step8.cpp b/Examples/Tutorial/Step8.cpp
index fa378c4c64..28555a588d 100644
--- a/Examples/Tutorial/Step8.cpp
+++ b/Examples/Tutorial/Step8.cpp
@@ -1,88 +1,88 @@
 /*===================================================================
 
 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 "Step8.h"
 
 #include "QmitkStdMultiWidget.h"
 
 #include "mitkGlobalInteraction.h"
 #include "mitkRenderingManager.h"
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 
 //##Documentation
 //## @brief As Step6, but with QmitkStdMultiWidget as widget
 Step8::Step8(int argc, char* argv[], QWidget *parent) :
   Step6(argc, argv, parent)
 {
 }
 
 void Step8::SetupWidgets()
 {
   //*************************************************************************
   // Part I: Create windows and pass the tree to it
   //*************************************************************************
 
   // Create toplevel widget with vertical layout
   QVBoxLayout* vlayout = new QVBoxLayout(this);
   vlayout->setMargin(0);
   vlayout->setSpacing(2);
 
   // Create viewParent widget with horizontal layout
   QWidget* viewParent = new QWidget(this);
   vlayout->addWidget(viewParent);
   QHBoxLayout* hlayout = new QHBoxLayout(viewParent);
   hlayout->setMargin(0);
 
   //*************************************************************************
   // Part Ia: create and initialize QmitkStdMultiWidget
   //*************************************************************************
   QmitkStdMultiWidget* multiWidget = new QmitkStdMultiWidget(viewParent);
 
   hlayout->addWidget(multiWidget);
 
   // Tell the multiWidget which DataStorage to render
   multiWidget->SetDataStorage(m_DataStorage);
 
   // Initialize views as axial, sagittal, coronar (from
   // top-left to bottom)
-  mitk::TimeSlicedGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(
+  mitk::TimeGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(
       m_DataStorage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
   // Initialize bottom-right view as 3D view
   multiWidget->GetRenderWindow4()->GetRenderer()->SetMapperID(
       mitk::BaseRenderer::Standard3D);
 
   // Enable standard handler for levelwindow-slider
   multiWidget->EnableStandardLevelWindow();
 
   // Add the displayed views to the DataStorage to see their positions in 2D and 3D
   multiWidget->AddDisplayPlaneSubTree();
   multiWidget->AddPlanesToDataStorage();
   multiWidget->SetWidgetPlanesVisibility(true);
 
   //*************************************************************************
   // Part II: Setup standard interaction with the mouse
   //*************************************************************************
 
   // Moving the cut-planes to click-point
   multiWidget->EnableNavigationControllerEventListening();
 }
 /**
  \example Step8.cpp
  */
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
index 8157651ebb..96ba28845f 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
@@ -1,698 +1,698 @@
 
 /*===================================================================
 
 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 "mitkConnectomicsNetwork.h"
 #include <boost/graph/clustering_coefficient.hpp>
 #include <boost/graph/betweenness_centrality.hpp>
 
 /* Constructor and Destructor */
 mitk::ConnectomicsNetwork::ConnectomicsNetwork()
 : m_IsModified( false )
 {
 }
 
 mitk::ConnectomicsNetwork::~ConnectomicsNetwork()
 {
 }
 
 /* Wrapper methods */
 
 bool mitk::ConnectomicsNetwork::EdgeExists(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB ) const
 {
   return boost::edge(vertexA, vertexB, m_Network ).second;
 }
 
 void mitk::ConnectomicsNetwork::IncreaseEdgeWeight(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB )
 {
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight++;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge(
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB
                                         )
 {
   AddEdge(vertexA, vertexB, m_Network[ vertexA ].id, m_Network[ vertexB ].id );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge(
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB,
                                         int sourceID, int targetID, int weight )
 {
   boost::add_edge( vertexA, vertexB, m_Network );
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].sourceId = sourceID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].targetId = targetID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight = weight;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].edge_weight = 1.0;
 
   SetIsModified( true );
 }
 
 mitk::ConnectomicsNetwork::VertexDescriptorType mitk::ConnectomicsNetwork::AddVertex( int id )
 {
   VertexDescriptorType vertex = boost::add_vertex( m_Network );
   m_Network[vertex].id = id;
 
   SetIsModified( true );
 
   return vertex;
 }
 
 void mitk::ConnectomicsNetwork::SetLabel(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::string inLabel )
 {
   m_Network[vertex].label = inLabel;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::SetCoordinates(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::vector< float > inCoordinates )
 {
   m_Network[vertex].coordinates = inCoordinates;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::clear()
 {
   m_Network.clear();
 
   SetIsModified( true );
 }
 
 /* Superclass methods, that need to be implemented */
 void mitk::ConnectomicsNetwork::UpdateOutputInformation()
 {
 
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::ConnectomicsNetwork::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 bool mitk::ConnectomicsNetwork::VerifyRequestedRegion()
 {
   return true;
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegion(const itk::DataObject *data )
 {
 
 }
 
 
 
 std::vector< mitk::ConnectomicsNetwork::NetworkNode >
 mitk::ConnectomicsNetwork::GetVectorOfAllNodes() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< NetworkNode > vectorOfNodes;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode tempNode;
 
     // the value of an iterator is a descriptor
     tempNode = m_Network[ *iterator ];
 
     vectorOfNodes.push_back( tempNode );
   }
 
   return vectorOfNodes;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
 mitk::ConnectomicsNetwork::GetVectorOfAllVertexDescriptors() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< VertexDescriptorType > vectorOfDescriptors;
 
   for ( ; iterator != end; ++iterator)
   {
     vectorOfDescriptors.push_back( *iterator );
   }
 
   return vectorOfDescriptors;
 }
 
 std::vector< std::pair<
 std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >
 , mitk::ConnectomicsNetwork::NetworkEdge > >
 mitk::ConnectomicsNetwork::GetVectorOfAllEdges() const
 {
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   std::vector<
     std::pair<
     std::pair< NetworkNode, NetworkNode >
     , NetworkEdge
     >
   > vectorOfEdges;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode sourceNode, targetNode;
     NetworkEdge tempEdge;
 
     // the value of an iterator is a descriptor
     tempEdge = m_Network[ *iterator ];
     sourceNode = m_Network[ boost::source( *iterator, m_Network ) ];
     targetNode = m_Network[ boost::target( *iterator, m_Network ) ];
 
     std::pair< NetworkNode, NetworkNode > nodePair( sourceNode, targetNode );
     std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > edgePair( nodePair, tempEdge);
     vectorOfEdges.push_back( edgePair );
   }
 
   return vectorOfEdges;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfVertices() const
 {
   return boost::num_vertices( m_Network );
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfEdges() const
 {
   return boost::num_edges( m_Network );
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumWeight() const
 {
   int maxWeight( 0 );
 
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   for ( ; iterator != end; ++iterator)
   {
     int tempWeight;
 
     // the value of an iterator is a descriptor
     tempWeight = m_Network[ *iterator ].weight;
 
     if( tempWeight > maxWeight )
     {
       maxWeight = tempWeight;
     }
   }
 
   return maxWeight;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfSelfLoops()
 {
   int noOfSelfLoops( 0 );
 
   std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > >
     edgeVector =  GetVectorOfAllEdges();
 
   for( int index = 0; index < edgeVector.size() ; index++ )
   {
     double sourceX, sourceY, sourceZ, targetX, targetY, targetZ;
 
     sourceX = edgeVector[ index ].first.first.coordinates[0] ;
     sourceY = edgeVector[ index ].first.first.coordinates[1] ;
     sourceZ = edgeVector[ index ].first.first.coordinates[2] ;
     targetX = edgeVector[ index ].first.second.coordinates[0] ;
     targetY = edgeVector[ index ].first.second.coordinates[1] ;
     targetZ = edgeVector[ index ].first.second.coordinates[2] ;
 
     // if the coordinates are the same
     if(
       sourceX > ( targetX - 0.01 ) &&
       sourceX < ( targetX + 0.01 ) &&
       sourceY > ( targetY - 0.01 ) &&
       sourceY < ( targetY + 0.01 ) &&
       sourceZ > ( targetZ - 0.01 ) &&
       sourceZ < ( targetZ + 0.01 )
       )
     {
       noOfSelfLoops++;
     }
   }
 
   return noOfSelfLoops;
 }
 
 double mitk::ConnectomicsNetwork::GetAverageDegree()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
 
   return ( ( edges * 2.0 ) / vertices );
 }
 
 double mitk::ConnectomicsNetwork::GetConnectionDensity()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
   double numberOfPossibleEdges = vertices * ( vertices - 1 ) / 2 ;
 
   return ( edges / numberOfPossibleEdges );
 }
 
 std::vector< int > mitk::ConnectomicsNetwork::GetDegreeOfNodes( ) const
 {
   std::vector< int > vectorOfDegree;
 
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie( iterator, end ) = boost::vertices( m_Network );
 
   vectorOfDegree.resize( this->GetNumberOfVertices() );
 
   for ( ; iterator != end; ++iterator)
   {
     // the value of an iterator is a descriptor
     vectorOfDegree[ m_Network[ *iterator ].id ] = GetVectorOfAdjacentNodes( *iterator ).size();
   }
   return vectorOfDegree;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
 mitk::ConnectomicsNetwork::GetVectorOfAdjacentNodes( mitk::ConnectomicsNetwork::VertexDescriptorType vertex ) const
 {
   std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > vectorOfAdjacentNodes;
 
   boost::graph_traits<NetworkType>::adjacency_iterator adjIter, adjEnd;
 
   boost::tie( adjIter, adjEnd ) = boost::adjacent_vertices( vertex, m_Network);
 
   for ( ; adjIter != adjEnd; ++adjIter)
   {
     vectorOfAdjacentNodes.push_back( *adjIter );
   }
 
   return vectorOfAdjacentNodes;
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumDegree() const
 {
   int maximumDegree( 0 );
 
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     if( maximumDegree < vectorOfDegree[ index ] )
     {
       maximumDegree = vectorOfDegree[ index ];
     }
   }
 
   return maximumDegree;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetLocalClusteringCoefficients( ) const
 {
   std::vector< double > vectorOfClusteringCoefficients;
 
   typedef boost::graph_traits<NetworkType>::vertex_iterator vertexIter;
 
   vectorOfClusteringCoefficients.resize( this->GetNumberOfVertices() );
 
   std::pair<vertexIter, vertexIter> vertexPair;
 
   //for every vertex calculate the clustering coefficient
   int size = vectorOfClusteringCoefficients.size();
   for (vertexPair = vertices(m_Network); vertexPair.first != vertexPair.second; ++vertexPair.first)
   {
     int index = m_Network[ *vertexPair.first ].id;
 
     if( index > size )
     {
       MITK_ERROR << "Trying to access out of bounds clustering coefficient";
       continue;
     }
 
     vectorOfClusteringCoefficients[ index ] =
       boost::clustering_coefficient(m_Network,*vertexPair.first) ;
   }
 
   return vectorOfClusteringCoefficients;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetClusteringCoefficientsByDegree( )
 {
   std::vector< double > vectorOfClusteringCoefficients = GetLocalClusteringCoefficients();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree;
   vectorOfClusteringCoefficientsByDegree.resize( GetMaximumDegree() + 1, 0 );
 
   // c_{mean}(k) = frac{1}_{N_{k}} sum_{i in Y(k)} c_{i}
   // where N_{k} is the number of vertices of degree k
   // Y(k) is the set of vertices of degree k
   // c_{i} is the local clustering coefficient of vertex i
   for( int degree( 0 ); degree < vectorOfClusteringCoefficientsByDegree.size(); ++degree )
   {
     vectorOfClusteringCoefficientsByDegree[ degree ] = 0;
     int n_k( 0 );
     for( int index( 0 ); index < vectorOfDegree.size(); ++index )
     {
       if( degree == vectorOfDegree[ index ] )
       {// if in Y( degree )
         vectorOfClusteringCoefficientsByDegree[ degree ] += vectorOfClusteringCoefficients[ index ];
         n_k++;
       }
     }
     if( n_k != 0 )
     {
       vectorOfClusteringCoefficientsByDegree[ degree ] =
         vectorOfClusteringCoefficientsByDegree[ degree ] / n_k;
     }
   }
 
   return vectorOfClusteringCoefficientsByDegree;
 }
 
 double mitk::ConnectomicsNetwork::GetGlobalClusteringCoefficient( )
 {
   double globalClusteringCoefficient( 0.0 );
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree = GetClusteringCoefficientsByDegree();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
   std::vector< int > degreeDistribution;
   degreeDistribution.resize( vectorOfClusteringCoefficientsByDegree.size(), 0 );
 
   int normalizationParameter( 0 );
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     degreeDistribution[ vectorOfDegree[ index ] ]++;
     normalizationParameter++;
   }
   // c_{mean} = sum_{k} P_{k} c_{mean}(k)
   // where P_{k} is the degree distribution
   // k is the degree
   for( int degree( 0 ); degree < degreeDistribution.size(); ++degree )
   {
     globalClusteringCoefficient +=
       degreeDistribution[ degree ] / ( (double) normalizationParameter)
       * vectorOfClusteringCoefficientsByDegree[ degree ];
   }
 
   return globalClusteringCoefficient;
 }
 
 mitk::ConnectomicsNetwork::NetworkType* mitk::ConnectomicsNetwork::GetBoostGraph()
 {
   return &m_Network;
 }
 
 
 bool mitk::ConnectomicsNetwork::GetIsModified() const
 {
   return m_IsModified;
 }
 
 
 void mitk::ConnectomicsNetwork::SetIsModified( bool value)
 {
   m_IsModified = value;
 }
 
 
 mitk::ConnectomicsNetwork::NetworkNode mitk::ConnectomicsNetwork::GetNode( VertexDescriptorType vertex ) const
 {
   return m_Network[ vertex ];
 }
 
 
 mitk::ConnectomicsNetwork::NetworkEdge mitk::ConnectomicsNetwork::GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const
 {
   return m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ];
 }
 
 void mitk::ConnectomicsNetwork::UpdateBounds( )
 {
   float min = itk::NumericTraits<float>::min();
   float max = itk::NumericTraits<float>::max();
   float bounds[] = {max, min, max, min, max, min};
 
   std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = this->GetVectorOfAllNodes();
 
   if( nodeVector.size() == 0 )
   {
     bounds[0] = 0;
     bounds[1] = 1;
     bounds[2] = 0;
     bounds[3] = 1;
     bounds[4] = 0;
     bounds[5] = 1;
   }
 
   // for each direction, make certain the point is in between
   for( int index(0), end(nodeVector.size()) ; index < end; index++ )
   {
     for( int direction(0); direction < nodeVector.at( index ).coordinates.size(); direction++ )
     {
       if( nodeVector.at( index ).coordinates.at(direction) < bounds[ 2 * direction ]  )
       {
         bounds[ 2 * direction ] = nodeVector.at( index ).coordinates.at(direction);
       }
 
       if( nodeVector.at( index ).coordinates.at(direction) > bounds[ 2 * direction + 1]  )
       {
         bounds[ 2 * direction + 1] = nodeVector.at( index ).coordinates.at(direction);
       }
     }
   }
 
 
   // provide some border margin
   for(int i=0; i<=4; i+=2)
   {
     bounds[i] -=10;
   }
 
   for(int i=1; i<=5; i+=2)
   {
     bounds[i] +=10;
   }
 
   this->GetGeometry()->SetFloatBounds(bounds);
-  this->GetTimeSlicedGeometry()->UpdateInformation();
+  this->GetTimeGeometry()->Update();
 }
 
 void mitk::ConnectomicsNetwork::PruneUnconnectedSingleNodes()
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // set to true if iterators are invalidated by deleting a vertex
   bool vertexHasBeenRemoved( true );
 
   // if no vertex has been removed in the last loop, we are done
   while( vertexHasBeenRemoved )
   {
     vertexHasBeenRemoved = false;
     // sets iterator to start and end to end
     boost::tie(iterator, end) = boost::vertices( m_Network );
 
     for ( ; iterator != end && !vertexHasBeenRemoved; ++iterator)
     {
       // If the node has no adjacent vertices it should be deleted
       if( GetVectorOfAdjacentNodes( *iterator ).size() == 0 )
       {
         vertexHasBeenRemoved = true;
         // this invalidates all iterators
         boost::remove_vertex( *iterator, m_Network );
       }
     }
   }
 
   UpdateIDs();
 }
 
 void mitk::ConnectomicsNetwork::UpdateIDs()
 {
   boost::graph_traits<NetworkType>::vertex_iterator v_i, v_end;
   boost::graph_traits<NetworkType>::edge_iterator e_i, e_end;
 
   // update node ids
   boost::tie( v_i, v_end ) = boost::vertices( m_Network );
 
   for ( ; v_i != v_end; ++v_i)
   {
     m_Network[*v_i].id = *v_i;
   }
 
   // update edge information
   boost::tie(e_i, e_end) = boost::edges( m_Network );
 
   for ( ; e_i != e_end; ++e_i)
   {
     m_Network[ *e_i ].sourceId = m_Network[ boost::source( *e_i, m_Network ) ].id;
     m_Network[ *e_i ].targetId = m_Network[ boost::target( *e_i, m_Network ) ].id;
   }
   this->SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::PruneEdgesBelowWeight( int targetWeight )
 {
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // set to true if iterators are invalidated by deleting a vertex
   bool edgeHasBeenRemoved( true );
 
   // if no vertex has been removed in the last loop, we are done
   while( edgeHasBeenRemoved )
   {
     edgeHasBeenRemoved = false;
     // sets iterator to start and end to end
     boost::tie(iterator, end) = boost::edges( m_Network );
 
     for ( ; iterator != end && !edgeHasBeenRemoved; ++iterator)
     {
       // If the node has no adjacent edges it should be deleted
       if( m_Network[ *iterator ].weight < targetWeight )
       {
         edgeHasBeenRemoved = true;
         // this invalidates all iterators
         boost::remove_edge( *iterator, m_Network );
       }
     }
   }
 
   // this will remove any nodes which, after deleting edges are now
   // unconnected, also this calls UpdateIDs()
   PruneUnconnectedSingleNodes();
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetNodeBetweennessVector() const
 {
   std::vector< double > betweennessVector;
 
   betweennessVector.clear();
   betweennessVector.resize( this->GetNumberOfVertices() );
 
   boost::brandes_betweenness_centrality(
     m_Network,
     boost::centrality_map(
     boost::make_iterator_property_map( betweennessVector.begin(), boost::get( &NetworkNode::id, m_Network ), double() )
     ).vertex_index_map( boost::get( &NetworkNode::id, m_Network ) )
     );
 
   return betweennessVector;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetEdgeBetweennessVector() const
 {
   // std::map used for convenient initialization
   typedef std::map<EdgeDescriptorType, int> EdgeIndexStdMap;
   EdgeIndexStdMap stdEdgeIndex;
   // associative property map needed for iterator property map-wrapper
   typedef boost::associative_property_map< EdgeIndexStdMap > EdgeIndexMap;
   EdgeIndexMap edgeIndex(stdEdgeIndex);
 
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   int i(0);
   for ( ; iterator != end; ++iterator, ++i)
   {
     stdEdgeIndex.insert(std::pair< EdgeDescriptorType, int >( *iterator, i));
   }
 
   // Define EdgeCentralityMap
   std::vector< double > edgeBetweennessVector(boost::num_edges( m_Network ), 0.0);
   // Create the external property map
   boost::iterator_property_map< std::vector< double >::iterator, EdgeIndexMap >
     e_centrality_map(edgeBetweennessVector.begin(), edgeIndex);
 
   // Define VertexCentralityMap
   typedef boost::property_map< NetworkType, boost::vertex_index_t>::type VertexIndexMap;
   VertexIndexMap vertexIndex = get(boost::vertex_index, m_Network );
   std::vector< double > betweennessVector(boost::num_vertices( m_Network ), 0.0);
   // Create the external property map
   boost::iterator_property_map< std::vector< double >::iterator, VertexIndexMap >
     v_centrality_map(betweennessVector.begin(), vertexIndex);
 
   boost::brandes_betweenness_centrality( m_Network, v_centrality_map, e_centrality_map );
 
   return edgeBetweennessVector;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetShortestDistanceVectorFromLabel( std::string targetLabel ) const
 {
   std::vector< VertexDescriptorType > predecessorMap( boost::num_vertices( m_Network ) );
   int numberOfNodes( boost::num_vertices( m_Network ) );
 
   std::vector< double > distanceMatrix;
   distanceMatrix.resize( numberOfNodes );
 
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
   {
     ++iterator;
   }
 
   if( iterator == end )
   {
     MITK_WARN << "Label not found";
     return distanceMatrix;
   }
 
   boost::dijkstra_shortest_paths(m_Network, *iterator, boost::predecessor_map(&predecessorMap[ 0 ]).distance_map(&distanceMatrix[ 0 ]).weight_map( boost::get( &NetworkEdge::edge_weight ,m_Network ) ) ) ;
 
   return distanceMatrix;
 }
 
 bool mitk::ConnectomicsNetwork::CheckForLabel( std::string targetLabel ) const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
   {
     ++iterator;
   }
 
   if( iterator == end )
   {
     return false;
   }
 
   return true;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
index 1c661d6a62..11815dd761 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
@@ -1,311 +1,312 @@
 /*===================================================================
 
 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 MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
 #define MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
 
 #include "mitkDWIHeadMotionCorrectionFilter.h"
 
 #include "itkSplitDWImageFilter.h"
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
 
 #include "mitkImageTimeSelector.h"
 
 #include "mitkPyramidImageRegistrationMethod.h"
 #include "mitkImageToDiffusionImageSource.h"
 
 #include "mitkDiffusionImageCorrectionFilter.h"
 
 #include <vector>
 
 #include "mitkIOUtil.h"
 #include <itkImage.h>
 
 template< typename DiffusionPixelType>
 mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>
   ::DWIHeadMotionCorrectionFilter():
 m_CurrentStep(0),
   m_Steps(100),
   m_IsInValidState(true),
   m_AbortRegistration(false)
 {
 
 }
 
 template< typename DiffusionPixelType>
 void mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>
   ::GenerateData()
 {
   typedef itk::SplitDWImageFilter< DiffusionPixelType, DiffusionPixelType> SplitFilterType;
 
   DiffusionImageType* input = const_cast<DiffusionImageType*>(this->GetInput(0));
 
   unsigned int numberOfSteps = input->GetVectorImage()->GetNumberOfComponentsPerPixel () ;
   m_Steps = numberOfSteps;
   //
   //  (1) Extract the b-zero images to a 3d+t image, register them by NCorr metric and
   //     rigid registration : they will then be used are reference image for registering
   //     the gradient images
   //
   typedef itk::B0ImageExtractionToSeparateImageFilter< DiffusionPixelType, DiffusionPixelType> B0ExtractorType;
   typename B0ExtractorType::Pointer b0_extractor = B0ExtractorType::New();
   b0_extractor->SetInput( input->GetVectorImage() );
   b0_extractor->SetDirections( input->GetDirections() );
   b0_extractor->Update();
 
   mitk::Image::Pointer b0Image = mitk::Image::New();
   b0Image->InitializeByItk( b0_extractor->GetOutput() );
   b0Image->SetImportChannel( b0_extractor->GetOutput()->GetBufferPointer(),
     mitk::Image::CopyMemory );
 
   // (2.1) Use the extractor to access the extracted b0 volumes
   mitk::ImageTimeSelector::Pointer t_selector =
     mitk::ImageTimeSelector::New();
 
   t_selector->SetInput( b0Image );
   t_selector->SetTimeNr(0);
   t_selector->Update();
 
   // first unweighted image as reference space for the registration
   mitk::Image::Pointer b0referenceImage = t_selector->GetOutput();
 
   mitk::PyramidImageRegistrationMethod::Pointer registrationMethod = mitk::PyramidImageRegistrationMethod::New();
   registrationMethod->SetFixedImage( b0referenceImage );
   registrationMethod->SetTransformToRigid();
 
   // the unweighted images are of same modality
   registrationMethod->SetCrossModalityOff();
 
   // use the advanced (windowed sinc) interpolation
   registrationMethod->SetUseAdvancedInterpolation(true);
 
   // Initialize the temporary output image
   mitk::Image::Pointer registeredB0Image = b0Image->Clone();
   const unsigned int numberOfb0Images = b0Image->GetTimeSteps();
 
   if( numberOfb0Images > 1)
   {
     mitk::ImageTimeSelector::Pointer t_selector2 =
       mitk::ImageTimeSelector::New();
 
     t_selector2->SetInput( b0Image );
 
     for( unsigned int i=1; i<numberOfb0Images; i++)
     {
 
       m_CurrentStep = i + 1;
       if( m_AbortRegistration == true) {
         m_IsInValidState = false;
         mitkThrow() << "Stopped by user.";
       };
 
       t_selector2->SetTimeNr(i);
       t_selector2->Update();
 
       registrationMethod->SetMovingImage( t_selector2->GetOutput() );
 
       try
       {
         MITK_INFO << " === (" << i <<"/"<< numberOfb0Images-1 << ") :: Starting registration";
         registrationMethod->Update();
       }
       catch( const itk::ExceptionObject& e)
       {
         m_IsInValidState = false;
         mitkThrow() << "Failed to register the b0 images, the PyramidRegistration threw an exception: \n" << e.what();
       }
 
       // import volume to the inter-results
       registeredB0Image->SetImportVolume( registrationMethod->GetResampledMovingImage()->GetData(),
         i, 0, mitk::Image::ReferenceMemory );
 
     }
 
     // use the accumulateImageFilter as provided by the ItkAccumulateFilter method in the header file
     AccessFixedDimensionByItk_1(registeredB0Image, ItkAccumulateFilter, (4), b0referenceImage );
 
   }
 
 
   //
   // (2) Split the diffusion image into a 3d+t regular image, extract only the weighted images
   //
   typename SplitFilterType::Pointer split_filter = SplitFilterType::New();
   split_filter->SetInput (input->GetVectorImage() );
   split_filter->SetExtractAllAboveThreshold(20, input->GetB_ValueMap() );
 
   try
   {
     split_filter->Update();
   }
   catch( const itk::ExceptionObject &e)
   {
     m_IsInValidState = false;
     mitkThrow() << " Caught exception from SplitImageFilter : " << e.what();
   }
 
   mitk::Image::Pointer splittedImage = mitk::Image::New();
   splittedImage->InitializeByItk( split_filter->GetOutput() );
   splittedImage->SetImportChannel( split_filter->GetOutput()->GetBufferPointer(),
     mitk::Image::CopyMemory );
 
 
   //
   // (3) Use again the time-selector to access the components separately in order
   //     to perform the registration of  Image -> unweighted reference
   //
 
   mitk::PyramidImageRegistrationMethod::Pointer weightedRegistrationMethod
     = mitk::PyramidImageRegistrationMethod::New();
 
   weightedRegistrationMethod->SetTransformToAffine();
   weightedRegistrationMethod->SetCrossModalityOn();
 
   //
   //   - (3.1) Set the reference image
   //      - a single b0 image
   //      - average over the registered b0 images if multiple present
   //
   weightedRegistrationMethod->SetFixedImage( b0referenceImage );
   // use the advanced (windowed sinc) interpolation
   weightedRegistrationMethod->SetUseAdvancedInterpolation(true);
 
   //
   //   - (3.2) Register all timesteps in the splitted image onto the first reference
   //
   unsigned int maxImageIdx = splittedImage->GetTimeSteps();
-  mitk::TimeSlicedGeometry* tsg = splittedImage->GetTimeSlicedGeometry();
-  tsg->ExpandToNumberOfTimeSteps( maxImageIdx+1 );
+  mitk::TimeGeometry* tsg = splittedImage->GetTimeGeometry();
+  mitk::ProportionalTimeGeometry* ptg = dynamic_cast<ProportionalTimeGeometry*>(tsg);
+  ptg->Expand(maxImageIdx+1);
 
   mitk::Image::Pointer registeredWeighted = mitk::Image::New();
   registeredWeighted->Initialize( splittedImage->GetPixelType(0), *tsg );
 
   // insert the first unweighted reference as the first volume
   registeredWeighted->SetImportVolume( b0referenceImage->GetData(),
     0,0, mitk::Image::CopyMemory );
 
 
   // mitk::Image::Pointer registeredWeighted = splittedImage->Clone();
   // this time start at 0, we have only gradient images in the 3d+t file
   // the reference image comes form an other image
   mitk::ImageTimeSelector::Pointer t_selector_w =
     mitk::ImageTimeSelector::New();
 
   t_selector_w->SetInput( splittedImage );
 
   // store the rotation parts of the transformations in a vector
   typedef mitk::PyramidImageRegistrationMethod::TransformMatrixType MatrixType;
   std::vector< MatrixType > estimated_transforms;
 
 
   for( unsigned int i=0; i<maxImageIdx; i++)
   {
     m_CurrentStep = numberOfb0Images + i + 1;
     if( m_AbortRegistration == true) {
       m_IsInValidState = false;
       mitkThrow() << "Stopped by user.";
     };
 
     t_selector_w->SetTimeNr(i);
     t_selector_w->Update();
 
     weightedRegistrationMethod->SetMovingImage( t_selector_w->GetOutput() );
 
     try
     {
       MITK_INFO << " === (" << i+1 <<"/"<< maxImageIdx << ") :: Starting registration";
       weightedRegistrationMethod->Update();
     }
     catch( const itk::ExceptionObject& e)
     {
       m_IsInValidState = false;
       mitkThrow() << "Failed to register the b0 images, the PyramidRegistration threw an exception: \n" << e.what();
     }
 
     // allow expansion
     registeredWeighted->SetImportVolume( weightedRegistrationMethod->GetResampledMovingImage()->GetData(),
       i+1, 0, mitk::Image::CopyMemory);
 
     estimated_transforms.push_back( weightedRegistrationMethod->GetLastRotationMatrix() );
   }
 
 
   //
   // (4) Cast the resulting image back to an diffusion weighted image
   //
   typename DiffusionImageType::GradientDirectionContainerType *gradients = input->GetDirections();
   typename DiffusionImageType::GradientDirectionContainerType::Pointer gradients_new =
     DiffusionImageType::GradientDirectionContainerType::New();
   typename DiffusionImageType::GradientDirectionType bzero_vector;
   bzero_vector.fill(0);
 
   // compose the direction vector
   //  - no direction for the first image
   //  - correct ordering of the directions based on the index list
   gradients_new->push_back( bzero_vector );
 
   typename SplitFilterType::IndexListType index_list = split_filter->GetIndexList();
   typename SplitFilterType::IndexListType::const_iterator lIter = index_list.begin();
 
   while( lIter != index_list.end() )
   {
     gradients_new->push_back( gradients->at( *lIter ) );
     ++lIter;
   }
 
   typename mitk::ImageToDiffusionImageSource< DiffusionPixelType >::Pointer caster =
     mitk::ImageToDiffusionImageSource< DiffusionPixelType >::New();
 
   caster->SetImage( registeredWeighted );
   caster->SetBValue( input->GetB_Value() );
   caster->SetGradientDirections( gradients_new.GetPointer() );
 
   try
   {
     caster->Update();
   }
   catch( const itk::ExceptionObject& e)
   {
     m_IsInValidState = false;
     MITK_ERROR << "Casting back to diffusion image failed: ";
     mitkThrow() << "Subprocess failed with exception: " << e.what();
   }
 
   //
   // (5) Adapt the gradient directions according to the estimated transforms
   //
   typedef mitk::DiffusionImageCorrectionFilter< DiffusionPixelType > CorrectionFilterType;
   typename CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
 
   OutputImagePointerType output = caster->GetOutput();
   corrector->SetImage( output );
   corrector->CorrectDirections( estimated_transforms );
 
   //
   // (6) Pass the corrected image to the filters output port
   //
   m_CurrentStep += 1;
   this->GetOutput()->SetVectorImage(output->GetVectorImage());
   this->GetOutput()->SetB_Value(output->GetB_Value());
   this->GetOutput()->SetDirections(output->GetDirections());
   this->GetOutput()->SetMeasurementFrame(output->GetMeasurementFrame());
   this->GetOutput()->InitializeFromVectorImage();
 
   this->GetOutput()->Modified();
 }
 
 #endif // MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
index 444ca013a9..3a0f33f4d5 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
@@ -1,884 +1,885 @@
 /*===================================================================
 
 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 __mitkOdfVtkMapper2D_txx__
 #define __mitkOdfVtkMapper2D_txx__
 
 #include "mitkOdfVtkMapper2D.h"
 #include "mitkDataNode.h"
 #include "mitkBaseRenderer.h"
 #include "mitkMatrixConvert.h"
 #include "mitkGeometry3D.h"
+#include "mitkTimeGeometry.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkProperties.h"
 #include "mitkTensorImage.h"
 
 #include "vtkSphereSource.h"
 #include "vtkPropCollection.h"
 #include "vtkMaskedGlyph3D.h"
 #include "vtkGlyph2D.h"
 #include "vtkGlyph3D.h"
 #include "vtkMaskedProgrammableGlyphFilter.h"
 #include "vtkImageData.h"
 #include "vtkLinearTransform.h"
 #include "vtkCamera.h"
 #include "vtkPointData.h"
 #include "vtkTransformPolyDataFilter.h"
 #include "vtkTransform.h"
 #include "vtkOdfSource.h"
 #include "vtkDoubleArray.h"
 #include "vtkLookupTable.h"
 #include "vtkProperty.h"
 #include "vtkPolyDataNormals.h"
 #include "vtkLight.h"
 #include "vtkLightCollection.h"
 #include "vtkMath.h"
 #include "vtkFloatArray.h"
 #include "vtkDelaunay2D.h"
 #include "vtkMapper.h"
 
 #include "vtkRenderer.h"
 
 #include "itkOrientationDistributionFunction.h"
 
 #include "itkFixedArray.h"
 
 #include <mitkGL.h>
 #include "vtkOpenGLRenderer.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 template<class T, int N>
 vtkSmartPointer<vtkTransform> mitk::OdfVtkMapper2D<T,N>::m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
 
 template<class T, int N>
 vtkSmartPointer<vtkOdfSource> mitk::OdfVtkMapper2D<T,N>::m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
 
 template<class T, int N>
 float mitk::OdfVtkMapper2D<T,N>::m_Scaling;
 
 template<class T, int N>
 int mitk::OdfVtkMapper2D<T,N>::m_Normalization;
 
 template<class T, int N>
 int mitk::OdfVtkMapper2D<T,N>::m_ScaleBy;
 
 template<class T, int N>
 float mitk::OdfVtkMapper2D<T,N>::m_IndexParam1;
 
 template<class T, int N>
 float mitk::OdfVtkMapper2D<T,N>::m_IndexParam2;
 
 #define ODF_MAPPER_PI M_PI
 
 
 template<class T, int N>
 mitk::OdfVtkMapper2D<T,N>::LocalStorage::LocalStorage()
 {
     m_PropAssemblies.push_back(vtkPropAssembly::New());
     m_PropAssemblies.push_back(vtkPropAssembly::New());
     m_PropAssemblies.push_back(vtkPropAssembly::New());
 
     m_OdfsPlanes.push_back(vtkAppendPolyData::New());
     m_OdfsPlanes.push_back(vtkAppendPolyData::New());
     m_OdfsPlanes.push_back(vtkAppendPolyData::New());
 
     m_OdfsPlanes[0]->AddInput(vtkPolyData::New());
     m_OdfsPlanes[1]->AddInput(vtkPolyData::New());
     m_OdfsPlanes[2]->AddInput(vtkPolyData::New());
 
     m_OdfsActors.push_back(vtkActor::New());
     m_OdfsActors.push_back(vtkActor::New());
     m_OdfsActors.push_back(vtkActor::New());
 
     m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud();
     m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud();
     m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud();
 
     m_OdfsMappers.push_back(vtkPolyDataMapper::New());
     m_OdfsMappers.push_back(vtkPolyDataMapper::New());
     m_OdfsMappers.push_back(vtkPolyDataMapper::New());
 
     vtkLookupTable *lut = vtkLookupTable::New();
 
     m_OdfsMappers[0]->SetLookupTable(lut);
     m_OdfsMappers[1]->SetLookupTable(lut);
     m_OdfsMappers[2]->SetLookupTable(lut);
 
     m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]);
     m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]);
     m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]);
 }
 
 template<class T, int N>
 mitk::OdfVtkMapper2D<T,N>
 ::OdfVtkMapper2D()
 {
 
     m_Planes.push_back(vtkPlane::New());
     m_Planes.push_back(vtkPlane::New());
     m_Planes.push_back(vtkPlane::New());
 
     m_Cutters.push_back(vtkCutter::New());
     m_Cutters.push_back(vtkCutter::New());
     m_Cutters.push_back(vtkCutter::New());
 
     m_Cutters[0]->SetCutFunction( m_Planes[0] );
     m_Cutters[0]->GenerateValues( 1, 0, 1 );
 
     m_Cutters[1]->SetCutFunction( m_Planes[1] );
     m_Cutters[1]->GenerateValues( 1, 0, 1 );
 
     m_Cutters[2]->SetCutFunction( m_Planes[2] );
     m_Cutters[2]->GenerateValues( 1, 0, 1 );
 
     // Windowing the cutted planes in direction 1
     m_ThickPlanes1.push_back(vtkThickPlane::New());
     m_ThickPlanes1.push_back(vtkThickPlane::New());
     m_ThickPlanes1.push_back(vtkThickPlane::New());
 
     m_Clippers1.push_back(vtkClipPolyData::New());
     m_Clippers1.push_back(vtkClipPolyData::New());
     m_Clippers1.push_back(vtkClipPolyData::New());
 
     m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] );
     m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] );
     m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] );
 
     // Windowing the cutted planes in direction 2
     m_ThickPlanes2.push_back(vtkThickPlane::New());
     m_ThickPlanes2.push_back(vtkThickPlane::New());
     m_ThickPlanes2.push_back(vtkThickPlane::New());
 
     m_Clippers2.push_back(vtkClipPolyData::New());
     m_Clippers2.push_back(vtkClipPolyData::New());
     m_Clippers2.push_back(vtkClipPolyData::New());
 
     m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] );
     m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] );
     m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] );
 
     m_ShowMaxNumber = 500;
 }
 
 template<class T, int N>
 mitk::OdfVtkMapper2D<T,N>
 ::~OdfVtkMapper2D()
 {
 
 }
 
 template<class T, int N>
 mitk::Image* mitk::OdfVtkMapper2D<T,N>
 ::GetInput()
 {
     return static_cast<mitk::Image * > ( m_DataNode->GetData() );
 }
 
 template<class T, int N>
 vtkProp*  mitk::OdfVtkMapper2D<T,N>
 ::GetVtkProp(mitk::BaseRenderer* renderer)
 {
     LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
     return localStorage->m_PropAssemblies[GetIndex(renderer)];
 }
 
 template<class T, int N>
 int  mitk::OdfVtkMapper2D<T,N>
 ::GetIndex(mitk::BaseRenderer* renderer)
 {
     if(!strcmp(renderer->GetName(),"stdmulti.widget1"))
         return 0;
 
     if(!strcmp(renderer->GetName(),"stdmulti.widget2"))
         return 1;
 
     if(!strcmp(renderer->GetName(),"stdmulti.widget3"))
         return 2;
 
     return 0;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::GlyphMethod(void *arg)
 {
     vtkMaskedProgrammableGlyphFilter* pfilter=(vtkMaskedProgrammableGlyphFilter*)arg;
 
     double point[3];
     double debugpoint[3];
     pfilter->GetPoint(point);
     pfilter->GetPoint(debugpoint);
 
     itk::Point<double,3> p(point);
     Vector3D spacing = pfilter->GetGeometry()->GetSpacing();
     p[0] /= spacing[0];
     p[1] /= spacing[1];
     p[2] /= spacing[2];
 
     mitk::Point3D p2;
     pfilter->GetGeometry()->IndexToWorld( p, p2 );
     point[0] = p2[0];
     point[1] = p2[1];
     point[2] = p2[2];
 
     vtkPointData* data = pfilter->GetPointData();
     vtkDataArray* odfvals = data->GetArray("vector");
     vtkIdType id = pfilter->GetPointId();
     m_OdfTransform->Identity();
     m_OdfTransform->Translate(point[0],point[1],point[2]);
 
     typedef itk::OrientationDistributionFunction<float,N> OdfType;
     OdfType odf;
 
     if(odfvals->GetNumberOfComponents()==6)
     {
         float tensorelems[6] = {
             (float)odfvals->GetComponent(id,0),
             (float)odfvals->GetComponent(id,1),
             (float)odfvals->GetComponent(id,2),
             (float)odfvals->GetComponent(id,3),
             (float)odfvals->GetComponent(id,4),
             (float)odfvals->GetComponent(id,5),
         };
         itk::DiffusionTensor3D<float> tensor(tensorelems);
         odf.InitFromTensor(tensor);
     }
     else
     {
         for(int i=0; i<N; i++)
             odf[i] = (double)odfvals->GetComponent(id,i);
     }
 
     switch(m_ScaleBy)
     {
     case ODFSB_NONE:
         m_OdfSource->SetScale(m_Scaling);
         break;
     case ODFSB_GFA:
         m_OdfSource->SetScale(m_Scaling*odf.GetGeneralizedGFA(m_IndexParam1, m_IndexParam2));
         break;
     case ODFSB_PC:
         m_OdfSource->SetScale(m_Scaling*odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0));
         break;
     }
 
     m_OdfSource->SetNormalization(m_Normalization);
     m_OdfSource->SetOdf(odf);
     m_OdfSource->Modified();
 }
 
 template<class T, int N>
 typename mitk::OdfVtkMapper2D<T,N>::OdfDisplayGeometry mitk::OdfVtkMapper2D<T,N>
 ::MeasureDisplayedGeometry(mitk::BaseRenderer* renderer)
 {
     Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
     PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
 
     // set up the cutter orientation according to the current geometry of
     // the renderers plane
     vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];
     Point3D point = worldPlaneGeometry->GetOrigin();
     Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
     vnl2vtk( point.Get_vnl_vector(), vp );
     vnl2vtk( normal.Get_vnl_vector(), vnormal );
 
     mitk::DisplayGeometry::Pointer dispGeometry = renderer->GetDisplayGeometry();
     mitk::Vector2D size = dispGeometry->GetSizeInMM();
     mitk::Vector2D origin = dispGeometry->GetOriginInMM();
 
     //
     //  |------O------|
     //  |      d2     |
     //  L  d1  M      |
     //  |             |
     //  |-------------|
     //
 
     mitk::Vector2D M;
     mitk::Vector2D L;
     mitk::Vector2D O;
 
     M[0] = origin[0] + size[0]/2;
     M[1] = origin[1] + size[1]/2;
 
     L[0] = origin[0];
     L[1] = origin[1] + size[1]/2;
 
     O[0] = origin[0] + size[0]/2;
     O[1] = origin[1] + size[1];
 
     mitk::Point2D point1;
     point1[0] = M[0]; point1[1] = M[1];
     mitk::Point3D M3D;
     dispGeometry->Map(point1, M3D);
 
     point1[0] = L[0]; point1[1] = L[1];
     mitk::Point3D L3D;
     dispGeometry->Map(point1, L3D);
 
     point1[0] = O[0]; point1[1] = O[1];
     mitk::Point3D O3D;
     dispGeometry->Map(point1, O3D);
 
     double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0])
                      + (M3D[1]-L3D[1])*(M3D[1]-L3D[1])
                      + (M3D[2]-L3D[2])*(M3D[2]-L3D[2]));
     double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0])
                      + (M3D[1]-O3D[1])*(M3D[1]-O3D[1])
                      + (M3D[2]-O3D[2])*(M3D[2]-O3D[2]));
     double d = d1>d2 ? d1 : d2;
     d = d2;
 
     OdfDisplayGeometry retval;
     retval.vp[0] = vp[0];
     retval.vp[1] = vp[1];
     retval.vp[2] = vp[2];
     retval.vnormal[0] = vnormal[0];
     retval.vnormal[1] = vnormal[1];
     retval.vnormal[2] = vnormal[2];
     retval.normal[0] = normal[0];
     retval.normal[1] = normal[1];
     retval.normal[2] = normal[2];
     retval.d = d;
     retval.d1 = d1;
     retval.d2 = d2;
     retval.M3D[0] = M3D[0];
     retval.M3D[1] = M3D[1];
     retval.M3D[2] = M3D[2];
     retval.L3D[0] = L3D[0];
     retval.L3D[1] = L3D[1];
     retval.L3D[2] = L3D[2];
     retval.O3D[0] = O3D[0];
     retval.O3D[1] = O3D[1];
     retval.O3D[2] = O3D[2];
 
     retval.vp_original[0] = vp[0];
     retval.vp_original[1] = vp[1];
     retval.vp_original[2] = vp[2];
     retval.vnormal_original[0] = vnormal[0];
     retval.vnormal_original[1] = vnormal[1];
     retval.vnormal_original[2] = vnormal[2];
     retval.size[0] = size[0];
     retval.size[1] = size[1];
     retval.origin[0] = origin[0];
     retval.origin[1] = origin[1];
 
     return retval;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry dispGeo)
 {
     LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
     vtkLinearTransform * vtktransform =
             this->GetDataNode()->GetVtkTransform(this->GetTimestep());
 
     int index = GetIndex(renderer);
 
     vtkSmartPointer<vtkTransform> inversetransform = vtkSmartPointer<vtkTransform>::New();
     inversetransform->Identity();
     inversetransform->Concatenate(vtktransform->GetLinearInverse());
     double myscale[3];
     ((vtkTransform*)vtktransform)->GetScale(myscale);
     inversetransform->PostMultiply();
     inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
     inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
     inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
 
     // 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];
     m_VtkImage->GetDimensions(dims);
     double spac[3];
     m_VtkImage->GetSpacing(spac);
     if(fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[1])
             && fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[2]) )
     {
         if(fabs(dispGeo.vp[0]/spac[0]) < 0.4)
             dispGeo.vp[0] = 0.4*spac[0];
         if(fabs(dispGeo.vp[0]/spac[0]) > (dims[0]-1)-0.4)
             dispGeo.vp[0] = ((dims[0]-1)-0.4)*spac[0];
         dispGeo.vnormal[1] = 0;
         dispGeo.vnormal[2] = 0;
     }
 
     if(fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[0]) && fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[2]) )
     {
         if(fabs(dispGeo.vp[1]/spac[1]) < 0.4)
             dispGeo.vp[1] = 0.4*spac[1];
         if(fabs(dispGeo.vp[1]/spac[1]) > (dims[1]-1)-0.4)
             dispGeo.vp[1] = ((dims[1]-1)-0.4)*spac[1];
         dispGeo.vnormal[0] = 0;
         dispGeo.vnormal[2] = 0;
     }
 
     if(fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[1]) && fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[0]) )
     {
         if(fabs(dispGeo.vp[2]/spac[2]) < 0.4)
             dispGeo.vp[2] = 0.4*spac[2];
         if(fabs(dispGeo.vp[2]/spac[2]) > (dims[2]-1)-0.4)
             dispGeo.vp[2] = ((dims[2]-1)-0.4)*spac[2];
         dispGeo.vnormal[0] = 0;
         dispGeo.vnormal[1] = 0;
     }
 
 
     m_Planes[index]->SetTransform( (vtkAbstractTransform*)NULL );
     m_Planes[index]->SetOrigin( dispGeo.vp );
     m_Planes[index]->SetNormal( dispGeo.vnormal );
 
     vtkSmartPointer<vtkPoints> points;
     vtkSmartPointer<vtkPoints> tmppoints;
     vtkSmartPointer<vtkPolyData> polydata;
     vtkSmartPointer<vtkFloatArray> pointdata;
     vtkSmartPointer<vtkDelaunay2D> delaunay;
     vtkSmartPointer<vtkPolyData> cuttedPlane;
 
     // the cutter only works if we do not have a 2D-image
     // or if we have a 2D-image and want to see the whole image.
     //
     // for side views of 2D-images, we need some special treatment
     if(!( (dims[0] == 1 && dispGeo.vnormal[0] != 0) ||
           (dims[1] == 1 && dispGeo.vnormal[1] != 0) ||
           (dims[2] == 1 && dispGeo.vnormal[2] != 0) ))
     {
         m_Cutters[index]->SetCutFunction( m_Planes[index] );
         m_Cutters[index]->SetInput( m_VtkImage );
         m_Cutters[index]->Update();
         cuttedPlane = m_Cutters[index]->GetOutput();
     }
     else
     {
         // cutting of a 2D-Volume does not work,
         // so we have to build up our own polydata object
         cuttedPlane = vtkPolyData::New();
         points = vtkPoints::New();
         points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints());
         for(int i=0; i<m_VtkImage->GetNumberOfPoints(); i++)
         {
             points->SetPoint(i, m_VtkImage->GetPoint(i));
         }
         cuttedPlane->SetPoints(points);
 
         pointdata = vtkFloatArray::New();
         int comps  = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfComponents();
         pointdata->SetNumberOfComponents(comps);
         int tuples = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfTuples();
         pointdata->SetNumberOfTuples(tuples);
         for(int i=0; i<tuples; i++)
             pointdata->SetTuple(i,m_VtkImage->GetPointData()->GetScalars()->GetTuple(i));
         pointdata->SetName( "vector" );
         cuttedPlane->GetPointData()->AddArray(pointdata);
 
         int nZero1, nZero2;
         if(dims[0]==1)
         {
             nZero1 = 1; nZero2 = 2;
         }
         else if(dims[1]==1)
         {
             nZero1 = 0; nZero2 = 2;
         }
         else
         {
             nZero1 = 0; nZero2 = 1;
         }
 
         tmppoints = vtkPoints::New();
         for(int j=0; j<m_VtkImage->GetNumberOfPoints(); j++){
             double pt[3];
             m_VtkImage->GetPoint(j,pt);
             tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0);
         }
 
         polydata = vtkPolyData::New();
         polydata->SetPoints( tmppoints );
         delaunay = vtkDelaunay2D::New();
         delaunay->SetInput( polydata );
         delaunay->Update();
         vtkCellArray* polys = delaunay->GetOutput()->GetPolys();
         cuttedPlane->SetPolys(polys);
     }
 
     if(cuttedPlane->GetNumberOfPoints())
     {
         //  WINDOWING HERE
         inversetransform = vtkTransform::New();
         inversetransform->Identity();
         inversetransform->Concatenate(vtktransform->GetLinearInverse());
         double myscale[3];
         ((vtkTransform*)vtktransform)->GetScale(myscale);
         inversetransform->PostMultiply();
         inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
 
         dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.O3D[0];
         dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.O3D[1];
         dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.O3D[2];
         vtkMath::Normalize(dispGeo.vnormal);
         dispGeo.vp[0] = dispGeo.M3D[0];
         dispGeo.vp[1] = dispGeo.M3D[1];
         dispGeo.vp[2] = dispGeo.M3D[2];
 
         inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
         inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
 
         m_ThickPlanes1[index]->count = 0;
         m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)NULL );
         m_ThickPlanes1[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
         m_ThickPlanes1[index]->SetThickness(dispGeo.d2);
         m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] );
         m_Clippers1[index]->SetInput( cuttedPlane );
         m_Clippers1[index]->SetInsideOut(1);
         m_Clippers1[index]->Update();
 
         dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.L3D[0];
         dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.L3D[1];
         dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.L3D[2];
         vtkMath::Normalize(dispGeo.vnormal);
         dispGeo.vp[0] = dispGeo.M3D[0];
         dispGeo.vp[1] = dispGeo.M3D[1];
         dispGeo.vp[2] = dispGeo.M3D[2];
 
         inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
         inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
 
         m_ThickPlanes2[index]->count = 0;
         m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)NULL );
         m_ThickPlanes2[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
         m_ThickPlanes2[index]->SetThickness(dispGeo.d1);
         m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] );
         m_Clippers2[index]->SetInput( m_Clippers1[index]->GetOutput() );
         m_Clippers2[index]->SetInsideOut(1);
         m_Clippers2[index]->Update();
 
         cuttedPlane = m_Clippers2[index]->GetOutput ();
 
         if(cuttedPlane->GetNumberOfPoints())
         {
             localStorage->m_OdfsPlanes[index]->RemoveAllInputs();
 
             vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New();
             normals->SetInputConnection( m_OdfSource->GetOutputPort() );
             normals->SplittingOff();
             normals->ConsistencyOff();
             normals->AutoOrientNormalsOff();
             normals->ComputePointNormalsOn();
             normals->ComputeCellNormalsOff();
             normals->FlipNormalsOff();
             normals->NonManifoldTraversalOff();
 
             vtkSmartPointer<vtkTransformPolyDataFilter> trans = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
             trans->SetInputConnection( normals->GetOutputPort() );
             trans->SetTransform(m_OdfTransform);
 
             vtkSmartPointer<vtkMaskedProgrammableGlyphFilter> glyphGenerator = vtkSmartPointer<vtkMaskedProgrammableGlyphFilter>::New();
             glyphGenerator->SetMaximumNumberOfPoints(std::min(m_ShowMaxNumber,(int)cuttedPlane->GetNumberOfPoints()));
             glyphGenerator->SetRandomMode(0);
             glyphGenerator->SetUseMaskPoints(1);
             glyphGenerator->SetSource( trans->GetOutput() );
             glyphGenerator->SetInput(cuttedPlane);
             glyphGenerator->SetColorModeToColorBySource();
             glyphGenerator->SetInputArrayToProcess(0,0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector");
             glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry());
             glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator);
 
             try
             {
                 glyphGenerator->Update();
             }
             catch( itk::ExceptionObject& err )
             {
                 std::cout << err << std::endl;
             }
 
             localStorage->m_OdfsPlanes[index]->AddInput(glyphGenerator->GetOutput());
 
             localStorage->m_OdfsPlanes[index]->Update();
         }
     }
     localStorage->m_PropAssemblies[index]->VisibilityOn();
     if(localStorage->m_PropAssemblies[index]->GetParts()->IsItemPresent(localStorage->m_OdfsActors[index]))
         localStorage->m_PropAssemblies[index]->RemovePart(localStorage->m_OdfsActors[index]);
     localStorage->m_OdfsMappers[index]->SetInput(localStorage->m_OdfsPlanes[index]->GetOutput());
     localStorage->m_PropAssemblies[index]->AddPart(localStorage->m_OdfsActors[index]);
 }
 
 template<class T, int N>
 bool mitk::OdfVtkMapper2D<T,N>
 ::IsVisibleOdfs(mitk::BaseRenderer* renderer)
 {
     mitk::Image::Pointer input  = const_cast<mitk::Image*>(this->GetInput());
-    const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
-    if(inputTimeGeometry==NULL || inputTimeGeometry->GetTimeSteps()==0 || !inputTimeGeometry->IsValidTime(this->GetTimestep()))
+    const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
+    if(inputTimeGeometry==NULL || inputTimeGeometry->GetNumberOfTimeSteps()==0 || !inputTimeGeometry->IsValidTimeStep(this->GetTimestep()))
         return false;
 
     if(this->IsPlaneRotated(renderer))
         return false;
 
     bool retval = false;
     switch(GetIndex(renderer))
     {
     case 0:
         GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_T");
         break;
     case 1:
         GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_S");
         break;
     case 2:
         GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_C");
         break;
     }
 
     return retval;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::MitkRenderOverlay(mitk::BaseRenderer* renderer)
 {
     if ( this->IsVisibleOdfs(renderer)==false )
         return;
 
     if ( this->GetVtkProp(renderer)->GetVisibility() )
         this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer)
 {
     if ( this->IsVisibleOdfs( renderer )==false )
         return;
 
     if ( this->GetVtkProp(renderer)->GetVisibility() )
     {
         // adapt cam pos
         OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer);
         this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
     }
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer)
 {
     if ( this->IsVisibleOdfs(renderer)==false )
         return;
 
     if ( this->GetVtkProp(renderer)->GetVisibility() )
         this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
 
 }
 
 template<class T, int N>
 void mitk::OdfVtkMapper2D<T,N>
 ::Update(mitk::BaseRenderer* renderer)
 {
     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 ;
 
     std::string classname("TensorImage");
     if(classname.compare(input->GetNameOfClass())==0)
         m_VtkImage = dynamic_cast<mitk::TensorImage*>( this->GetInput() )->GetNonRgbVtkImageData();
 
     std::string qclassname("QBallImage");
     if(qclassname.compare(input->GetNameOfClass())==0)
         m_VtkImage = dynamic_cast<mitk::QBallImage*>( this->GetInput() )->GetNonRgbVtkImageData();
 
     if( m_VtkImage )
     {
         // make sure, that we have point data with more than 1 component (as vectors)
         vtkPointData* pointData = m_VtkImage->GetPointData();
         if ( pointData == NULL )
         {
             itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" );
             return ;
         }
         if ( pointData->GetNumberOfArrays() == 0 )
         {
             itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" );
             return ;
         }
         else if ( pointData->GetArray(0)->GetNumberOfComponents() != N
                   && pointData->GetArray(0)->GetNumberOfComponents() != 6 /*for tensor visualization*/)
         {
             itkWarningMacro( << "number of components != number of directions in ODF!" );
             return;
         }
         else if ( pointData->GetArrayName( 0 ) == NULL )
         {
             m_VtkImage->GetPointData()->GetArray(0)->SetName("vector");
         }
 
         GenerateDataForRenderer(renderer);
     }
     else
     {
         itkWarningMacro( << "m_VtkImage is NULL!" );
         return ;
     }
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
     LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
     OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer);
 
 
     if ( (localStorage->m_LastUpdateTime >= m_DataNode->GetMTime()) //was the node modified?
       && (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList()->GetMTime()) //was a property modified?
       && (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList(renderer)->GetMTime())
       && dispGeo.Equals(m_LastDisplayGeometry))
         return;
 
     localStorage->m_LastUpdateTime.Modified();
 
     if(!IsVisibleOdfs(renderer))
     {
         localStorage->m_OdfsActors[0]->VisibilityOff();
         localStorage->m_OdfsActors[1]->VisibilityOff();
         localStorage->m_OdfsActors[2]->VisibilityOff();
     }
     else
     {
         localStorage->m_OdfsActors[0]->VisibilityOn();
         localStorage->m_OdfsActors[1]->VisibilityOn();
         localStorage->m_OdfsActors[2]->VisibilityOn();
 
         m_OdfSource->SetAdditionalScale(GetMinImageSpacing(GetIndex(renderer)));
         ApplyPropertySettings();
         Slice(renderer, dispGeo);
         m_LastDisplayGeometry = dispGeo;
     }
 }
 
 template<class T, int N>
 double  mitk::OdfVtkMapper2D<T,N>::GetMinImageSpacing( int index )
 {
     // Spacing adapted scaling
     double spacing[3];
     m_VtkImage->GetSpacing(spacing);
     double min;
     if(index==0)
     {
         min = spacing[0];
         min = min > spacing[1] ? spacing[1] : min;
     }
     if(index==1)
     {
         min = spacing[1];
         min = min > spacing[2] ? spacing[2] : min;
     }
     if(index==2)
     {
         min = spacing[0];
         min = min > spacing[2] ? spacing[2] : min;
     }
     return min;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::ApplyPropertySettings()
 {
     this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling );
     this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber );
 
     OdfNormalizationMethodProperty* nmp = dynamic_cast<OdfNormalizationMethodProperty*>(this->GetDataNode()->GetProperty( "Normalization" ));
     if(nmp)
         m_Normalization = nmp->GetNormalization();
 
     OdfScaleByProperty* sbp = dynamic_cast<OdfScaleByProperty*>(this->GetDataNode()->GetProperty( "ScaleBy" ));
     if(sbp)
         m_ScaleBy = sbp->GetScaleBy();
 
     this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1);
     this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2);
 }
 
 template <class T, int N>
 bool mitk::OdfVtkMapper2D<T,N>
 ::IsPlaneRotated(mitk::BaseRenderer* renderer)
 {
     Geometry2D::ConstPointer worldGeometry =
             renderer->GetCurrentWorldGeometry2D();
     PlaneGeometry::ConstPointer worldPlaneGeometry =
             dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
 
     vtkFloatingPointType vnormal[ 3 ];
     Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
     vnl2vtk( normal.Get_vnl_vector(), vnormal );
 
     vtkLinearTransform * vtktransform =
             this->GetDataNode()->GetVtkTransform(this->GetTimestep());
 
     vtkSmartPointer<vtkTransform> inversetransform = vtkSmartPointer<vtkTransform>::New();
     inversetransform->Identity();
     inversetransform->Concatenate(vtktransform->GetLinearInverse());
     double* n = inversetransform->TransformNormal(vnormal);
 
     int nonZeros = 0;
     for (int j=0; j<3; j++)
     {
         if (fabs(n[j])>mitk::eps){
             nonZeros++;
         }
     }
     if(nonZeros>1)
         return true;
 
     return false;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer*  /*renderer*/, bool  /*overwrite*/)
 {
     node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 150 ) );
     node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
     node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
     node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
     node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
     node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
     node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
     node->SetProperty( "VisibleOdfs_T", mitk::BoolProperty::New( false ) );
     node->SetProperty( "VisibleOdfs_C", mitk::BoolProperty::New( false ) );
     node->SetProperty( "VisibleOdfs_S", mitk::BoolProperty::New( false ) );
     node->SetProperty ("layer", mitk::IntProperty::New(100));
     node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
 }
 
 #endif // __mitkOdfVtkMapper2D_txx__
 
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
index e3712b7701..3c3d5cc9e3 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
@@ -1,356 +1,356 @@
 /*===================================================================
 
 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 __mitkNrrdTbssRoiReader_cpp
 #define __mitkNrrdTbssRoiReader_cpp
 
 #include "mitkNrrdTbssRoiImageReader.h"
 
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 
 #include <itkImageFileWriter.h>
 
 #include <iostream>
 #include <fstream>
 
 #include "itksys/SystemTools.hxx"
 
 namespace mitk
 {
 
 
   void NrrdTbssRoiImageReader
       ::GenerateData()
   {
 
     try
     {
 
       // Change locale if needed
       const std::string& locale = "C";
       const std::string& currLocale = setlocale( LC_ALL, NULL );
 
       if ( locale.compare(currLocale)!=0 )
       {
         try
         {
           MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
           setlocale(LC_ALL, locale.c_str());
         }
         catch(...)
         {
           MITK_INFO << "Could not set locale " << locale;
         }
       }
 
 
 
       // READ IMAGE INFORMATION
       const unsigned int MINDIM = 3;
       const unsigned int MAXDIM = 4;
 
       MITK_INFO << "loading " << m_FileName << " via mitk::NrrdTbssImageReader... " << std::endl;
 
       // Check to see if we can read the file given the name or prefix
       if ( m_FileName == "" )
       {
         itkWarningMacro( << "Filename is empty!" )
         return;
       }
 
       itk::NrrdImageIO::Pointer imageIO = itk::NrrdImageIO::New();
       imageIO->SetFileName( m_FileName.c_str() );
       imageIO->ReadImageInformation();
 
       unsigned int ndim = imageIO->GetNumberOfDimensions();
 
       if ( ndim < MINDIM || ndim > MAXDIM )
       {
         itkWarningMacro( << "Sorry, only dimensions 3 is supported. The given file has " << ndim << " dimensions!" )
         return;
       }
 
 
       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;
 
       float 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 << "ioRegion: " << ioRegion << std::endl;
       imageIO->SetIORegion( ioRegion );
       void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
       imageIO->Read( buffer );
       //mitk::Image::Pointer static_cast<OutputType*>(this->GetOutput())image = mitk::Image::New();
       if((ndim==4) && (dimensions[3]<=1))
         ndim = 3;
       if((ndim==3) && (dimensions[2]<=1))
         ndim = 2;
 
       static_cast<OutputType*>(this->GetPrimaryOutput())->Initialize( MakePixelType(imageIO), ndim, dimensions );
       static_cast<OutputType*>(this->GetPrimaryOutput())->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*>
                                      (static_cast<OutputType*>
                                       (this->GetPrimaryOutput())->GetSlicedGeometry(0)->GetGeometry2D(0));
       planeGeometry->SetOrigin(origin);
       planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
       // re-initialize SlicedGeometry3D
       SlicedGeometry3D* slicedGeometry = static_cast<OutputType*>(this->GetPrimaryOutput())->GetSlicedGeometry(0);
       slicedGeometry->InitializeEvenlySpaced(planeGeometry, static_cast<OutputType*>(this->GetPrimaryOutput())->GetDimension(2));
       slicedGeometry->SetSpacing(spacing);
 
-      // re-initialize TimeSlicedGeometry
-      static_cast<OutputType*>(this->GetPrimaryOutput())->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, static_cast<OutputType*>(this->GetPrimaryOutput())->GetDimension(3));
+      // re-initialize TimeGeometry
+      dynamic_cast<ProportionalTimeGeometry *>(static_cast<OutputType*>(this->GetPrimaryOutput())->GetTimeGeometry())->Initialize(slicedGeometry, static_cast<OutputType*>(this->GetOutput(0))->GetDimension(3));
 
       buffer = NULL;
       MITK_INFO << "number of image components: "<< static_cast<OutputType*>(this->GetPrimaryOutput())->GetPixelType().GetNumberOfComponents() << std::endl;
 
 
 
       // READ TBSS HEADER INFORMATION
       ImageType::Pointer img;
 
       std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
       ext = itksys::SystemTools::LowerCase(ext);
       if (ext == ".roi")
       {
         typedef itk::ImageFileReader<ImageType> FileReaderType;
         FileReaderType::Pointer reader = FileReaderType::New();
         reader->SetFileName(this->m_FileName);
 
         reader->SetImageIO(imageIO);
         reader->Update();
 
         img = reader->GetOutput();
 
         static_cast<OutputType*>(this->GetPrimaryOutput())->SetImage(img);
 
         itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
         ReadRoiInfo(imgMetaDictionary);
 
 
 
       }
 
 
       // RESET LOCALE
       try
       {
         MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
 
       MITK_INFO << "...finished!" << std::endl;
 
     }
     catch(std::exception& e)
     {
       MITK_INFO << "Std::Exception while reading file!!";
       MITK_INFO << e.what();
       throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
     }
     catch(...)
     {
       MITK_INFO << "Exception while reading file!!";
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
     }
 
 
   }
 
 
 
   void NrrdTbssRoiImageReader
       ::ReadRoiInfo(itk::MetaDataDictionary dict)
   {
     std::vector<std::string> imgMetaKeys = dict.GetKeys();
     std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
     std::string metaString;
     std::vector< itk::Index<3> > roi;
 
     for (; itKey != imgMetaKeys.end(); itKey ++)
     {
       double x,y,z;
       itk::Index<3> ix;
       itk::ExposeMetaData<std::string> (dict, *itKey, metaString);
 
       if (itKey->find("ROI_index") != std::string::npos)
       {
         MITK_INFO << *itKey << " ---> " << metaString;
         sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
         ix[0] = x; ix[1] = y; ix[2] = z;
         roi.push_back(ix);
       }
       else if(itKey->find("preprocessed FA") != std::string::npos)
       {
         MITK_INFO << *itKey << " ---> " << metaString;
         static_cast<OutputType*>(this->GetPrimaryOutput())->SetPreprocessedFA(true);
         static_cast<OutputType*>(this->GetPrimaryOutput())->SetPreprocessedFAFile(metaString);
       }
 
       // Name of structure
       if (itKey->find("structure") != std::string::npos)
       {
         MITK_INFO << *itKey << " ---> " << metaString;
         static_cast<OutputType*>(this->GetPrimaryOutput())->SetStructure(metaString);
       }
     }
     static_cast<OutputType*>(this->GetPrimaryOutput())->SetRoi(roi);
 
   }
 
 
   const char* NrrdTbssRoiImageReader
       ::GetFileName() const
   {
     return m_FileName.c_str();
   }
 
 
   void NrrdTbssRoiImageReader
       ::SetFileName(const char* aFileName)
   {
     m_FileName = aFileName;
   }
 
 
   const char* NrrdTbssRoiImageReader
       ::GetFilePrefix() const
   {
     return m_FilePrefix.c_str();
   }
 
 
   void NrrdTbssRoiImageReader
       ::SetFilePrefix(const char* aFilePrefix)
   {
     m_FilePrefix = aFilePrefix;
   }
 
 
   const char* NrrdTbssRoiImageReader
       ::GetFilePattern() const
   {
     return m_FilePattern.c_str();
   }
 
 
   void NrrdTbssRoiImageReader
       ::SetFilePattern(const char* aFilePattern)
   {
     m_FilePattern = aFilePattern;
   }
 
 
   bool NrrdTbssRoiImageReader
       ::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;
 
 
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext == ".roi")
     {
       itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
 
       typedef itk::ImageFileReader<ImageType> FileReaderType;
       FileReaderType::Pointer reader = FileReaderType::New();
       reader->SetImageIO(io);
       reader->SetFileName(filename);
 
       try
       {
         reader->Update();
       }
       catch(itk::ExceptionObject e)
       {
         MITK_INFO << e.GetDescription();
         return false;
       }
 
       return true;
 
 
     }
 
     return false;
   }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/ImageExtraction/mitkAutoCropImageFilter.cpp b/Modules/ImageExtraction/mitkAutoCropImageFilter.cpp
index bd73a10b8e..c3abf9c45c 100644
--- a/Modules/ImageExtraction/mitkAutoCropImageFilter.cpp
+++ b/Modules/ImageExtraction/mitkAutoCropImageFilter.cpp
@@ -1,368 +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() );
   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::TimeSlicedGeometry* timeSlicedGeometry = output->GetTimeSlicedGeometry();
-  timeSlicedGeometry->InitializeEvenlyTimed(slicedGeometry, output->GetDimension(3));
-  timeSlicedGeometry->CopyTimes(input->GetTimeSlicedGeometry());
+  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] >= 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;
-}
+}
\ No newline at end of file
diff --git a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
index a1883fa717..20cc9ef310 100644
--- a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
+++ b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
@@ -1,508 +1,508 @@
 /*===================================================================
 
 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 TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
+  const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
   if ( ( inputTimeGeometry == NULL )
-    || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
+    || ( inputTimeGeometry->GetNumberOfTimeSteps() == 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->MSToTimeStep( time );
+      timestep = inputTimeGeometry->TimePointToTimeStep( time );
     }
   }
   else timestep = m_TargetTimestep;
 
-  if ( inputTimeGeometry->IsValidTime( timestep ) == false )
+  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;
   }
 
   vtkFloatingPointType 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->GetTimeSlicedGeometry() == inputTimeGeometry );
+  assert( input->GetTimeGeometry() == inputTimeGeometry );
 
   // take transform of input image into account
-  Geometry3D* inputGeometry = inputTimeGeometry->GetGeometry3D( timestep );
+  Geometry3D* 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)
   vtkFloatingPointType 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)
     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)
     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;
   }
 
   vtkImageChangeInformation * unitSpacingImageFilter = vtkImageChangeInformation::New() ;
   unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
   unitSpacingImageFilter->SetInput( inputData );
 
   m_Reslicer->SetInput( unitSpacingImageFilter->GetOutput() );
   unitSpacingImageFilter->Delete();
 
   //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();
 
   //mitkIpPicDescriptor *pic = Pic2vtk::convert( reslicedImage );
 
   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->Initialize( pic );
   resultImage->SetSpacing( spacingVector );
   //resultImage->SetPicVolume( pic );
 
   //mitkIpPicFree(pic);
 
   /*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(m_Reslicer->GetOutput());
   resultImage->Initialize(inputImage->GetPixelType(), 2, dimensions);
   resultImage->SetSpacing(spacingVector);
   resultImage->SetSlice(m_Reslicer->GetOutput());*/
 }
 
 
 void mitk::ExtractDirectedPlaneImageFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
 
 
 bool mitk::ExtractDirectedPlaneImageFilter
 ::CalculateClippedPlaneBounds( const Geometry3D *boundingGeometry,
                 const PlaneGeometry *planeGeometry, vtkFloatingPointType *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 float *planeSpacing = planeGeometry->GetFloatSpacing();
     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,
           vtkFloatingPointType *bounds )
 {
   vtkFloatingPointType point1[3];
   vtkFloatingPointType 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 264762ea1c..41512e6df1 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_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::TimeSlicedGeometry* inputTimeGeometry = this->GetInput()->GetTimeSlicedGeometry();
+    const mitk::TimeGeometry* inputTimeGeometry = this->GetInput()->GetTimeGeometry();
     if ( m_ActualInputTimestep == -1)
     {
         ScalarType time = m_CurrentWorldGeometry2D->GetTimeBounds()[0];
         if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
         {
-            m_ActualInputTimestep = inputTimeGeometry->MSToTimeStep( time );
+            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 )
     {
         MITK_ERROR<< "mitk::ExtractDirectedPlaneImageFilterNew::GenerateData has no CurrentWorldGeometry2D 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);
 
     //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);
 
     //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::Geometry3D::Pointer newSliceGeometryTest = dynamic_cast<Geometry3D*>(m_CurrentWorldGeometry2D->Clone().GetPointer());
     newSliceGeometryTest->ChangeImageGeometryConsideringOriginOffset(true);
 
     //Workaround because of BUG (#6505)
     newSliceGeometryTest->GetIndexToWorldTransform()->SetMatrix(m_CurrentWorldGeometry2D->GetIndexToWorldTransform()->GetMatrix());
     //Workaround end
 
     newSliceGeometryTest->SetOrigin(origin);
     ScalarType bounds[6]={0, size[0], 0, 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/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp b/Modules/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp
index e5919e6c21..3bf009669c 100644
--- a/Modules/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp
+++ b/Modules/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp
@@ -1,776 +1,776 @@
 /*===================================================================
 
 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 <mitkWiiMoteInteractor.h>
 
 // mitk
 #include <mitkInteractionConst.h>
 #include <mitkVector.h>
 #include <mitkSurface.h>
 #include <mitkRenderingManager.h>
 #include <mitkVector.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkDataStorage.h>
 #include <mitkRenderingManager.h>
 #include <mitkVtkPropRenderer.h>
 
 // vtk
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 #include <vtkTransform.h>
 #include <vtkRenderer.h>
 #include <vtkMath.h>
 
 // vnl
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_inverse.h>
 
 #define _USE_MATH_DEFINES // otherwise, constants will not work
 #include <math.h>
 
 const double DELTATIME = 0.01;
 
 mitk::WiiMoteInteractor::WiiMoteInteractor(const char* type, DataNode* dataNode)
 : Interactor(type, dataNode)
 , m_OrientationX(0)
 , m_OrientationY(0)
 , m_OrientationZ(0)
 , m_xVelocity (0)
 , m_yVelocity (0)
 , m_zVelocity (0)
 , m_xAngle (0)
 , m_yAngle (0)
 , m_zAngle (0)
 , m_xValue (0)
 , m_yValue (0)
 , m_zValue (0)
 , m_InRotation(false)
 , m_TranslationMode(1)
 , m_OriginalGeometry(NULL)
 , m_SurfaceInteractionMode(1)
 {
   // save original geometry
   mitk::Geometry3D* temp = this->TransformCurrentDataInGeometry3D();
   try
   {
     m_OriginalGeometry = dynamic_cast<mitk::Geometry3D*>(temp->Clone().GetPointer());
   }
   catch(...)
   {
     MITK_WARN << "Original geometry could not be stored!";
   }
 
   // connect actions to methods
   CONNECT_ACTION(mitk::AcONWIIMOTEINPUT,OnWiiMoteInput);
   CONNECT_ACTION(mitk::AcONWIIMOTEBUTTONRELEASED,OnWiiMoteReleaseButton);
   CONNECT_ACTION(mitk::AcRESETVIEW,OnWiiMoteResetButton);
 }
 
 mitk::WiiMoteInteractor::~WiiMoteInteractor()
 {
 
 }
 
 bool mitk::WiiMoteInteractor::OnWiiMoteResetButton(Action* action, const mitk::StateEvent* stateEvent)
 {
   // resets the geometry, so that the
   // object will be returned to its
   // initial state
   try
   {
     mitk::Surface* surface
       = dynamic_cast<mitk::Surface*>(m_DataNode->GetData());
     mitk::Geometry3D::Pointer temp
       = dynamic_cast<mitk::Geometry3D*>(m_OriginalGeometry->Clone().GetPointer());
     surface->SetGeometry(temp);
 
     if(surface == NULL)
     {
       MITK_WARN << "Original geometry could not be used for reset!";
     }
 
     m_DataNode->SetData(surface);
 
     m_DataNode->Modified();
   }
   catch(...)
   {
     MITK_ERROR << "Original geometry could not be retrieved";
   }
 
   //reset the camera, so that the objects shown in the scene can be seen.
   const mitk::BaseRenderer* br = mitk::GlobalInteraction::GetInstance()->GetFocus();
 
   const mitk::VtkPropRenderer* glRenderer
     = dynamic_cast<const mitk::VtkPropRenderer*>(br);
   if (glRenderer)
   {
     vtkRenderer* vtkRenderer = glRenderer->GetVtkRenderer();
     mitk::DataStorage* ds = br->GetDataStorage();
     if (ds == NULL)
       return false;
 
     mitk::BoundingBox::Pointer bb = ds->ComputeBoundingBox();
 
     mitk::Point3D middle = bb->GetCenter();
     vtkRenderer->GetActiveCamera()->SetFocalPoint(middle[0],middle[1],middle[2]);
 
     vtkRenderer->ResetCamera();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     return true;
   }
 
   return false;
 }
 
 bool mitk::WiiMoteInteractor::OnWiiMoteInput(Action* action, const mitk::StateEvent* stateEvent)
 {
   const mitk::WiiMoteAllDataEvent* wiiMoteEvent;
   try
   {
     wiiMoteEvent =
       dynamic_cast<const mitk::WiiMoteAllDataEvent*>(stateEvent->GetEvent());
   }
   catch(...)
   {
     MITK_ERROR << "Event is not wiimote event and could not be transformed\n";
   }
 
   m_SurfaceInteractionMode = wiiMoteEvent->GetSurfaceInteractionMode();
 
   //this->FixedRotationAndTranslation(wiiMoteEvent);
 
   // -------------------- values for translation --------------------
   float xAccel = wiiMoteEvent->GetXAcceleration();
   float yAccel = wiiMoteEvent->GetYAcceleration();
   float zAccel = wiiMoteEvent->GetZAcceleration();
 
   float pitch = wiiMoteEvent->GetPitch();
   float roll = wiiMoteEvent->GetRoll();
 
   m_OrientationX = wiiMoteEvent->GetOrientationX();
   m_OrientationY = wiiMoteEvent->GetOrientationY();
   m_OrientationZ = wiiMoteEvent->GetOrientationZ();
 
   // substracts the proportionate force
   // applied by gravity depending on the
   // orientation
 
   float sinP = sin(pitch/180.0 * M_PI);
   float cosP = cos(pitch/180.0 * M_PI);
   float sinR = sin(roll/180.0 * M_PI);
   float cosR = cos(roll/180.0 * M_PI);
 
   // x acceleration
   if(m_OrientationZ >= 0)
   {
     m_xValue = xAccel - sinR * cosP;
   }
   else
   {
     m_xValue = xAccel + sinR * cosP;
   }
 
   //// against drift
   //if(std::abs(xAccel) < 0.2)
   //{
   //  m_xValue = 0;
   //}
 
   // y acceleration
   m_yValue = yAccel + sinP;
 
   //// against drift
   //if(std::abs(yAccel) < 0.2)
   //{
   //  m_yValue = 0;
   //}
 
   // z acceleration
   m_zValue = zAccel - cosP * cosR;
 
   //// against drift
   //if(std::abs(zAccel) < 0.3)
   //{
   //  m_zValue = 0;
   //}
 
   m_xVelocity += m_xValue;
   m_yVelocity += m_yValue;
   m_zVelocity -= m_zValue;
 
   // -------------------- values for rotation --------------------
 
   ScalarType pitchSpeed = wiiMoteEvent->GetPitchSpeed();
   ScalarType rollSpeed = wiiMoteEvent->GetRollSpeed();
   ScalarType yawSpeed = wiiMoteEvent->GetYawSpeed();
 
   // x angle
 
   if(std::abs(pitchSpeed) > 50
     && std::abs(pitchSpeed) < 1000)
   {
     if(m_SurfaceInteractionMode == 1)
     {
       m_xAngle = (pitchSpeed * DELTATIME);
     }
     else
     {
       m_xAngle = (-pitchSpeed * DELTATIME);
     }
   }
   else
   {
     m_xAngle = 0;
   }
 
   // y angle
 
   if(std::abs(rollSpeed) > 50
     && std::abs(rollSpeed) < 1000)
   {
     m_yAngle = (rollSpeed * DELTATIME);
   }
   else
   {
     m_yAngle = 0;
   }
 
   // z angle
 
   if(std::abs(yawSpeed) > 50
     && std::abs(yawSpeed) < 1000)
   {
     if(m_SurfaceInteractionMode == 1)
     {
       m_zAngle = (yawSpeed * DELTATIME);
     }
     else
     {
       m_zAngle = (-yawSpeed * DELTATIME);
     }
   }
   else
   {
     m_zAngle = 0;
   }
 
   // -------------------- rotation and translation --------------------
 
   bool result = false;
 
   result = this->DynamicRotationAndTranslation(this->TransformCurrentDataInGeometry3D());
 
   return result;
 }
 
 bool mitk::WiiMoteInteractor::OnWiiMoteReleaseButton(Action* action, const mitk::StateEvent* stateEvent)
 {
   m_xVelocity = 0;
   m_yVelocity = 0;
   m_zVelocity = 0;
 
   m_xValue = 0;
   m_yValue = 0;
   m_zValue = 0;
 
   m_xAngle = 0;
   m_yAngle = 0;
   m_zAngle = 0;
 
   // only for fixed translation
   m_InRotation = false;
   m_TranslationMode = 1;
 
   return true;
 }
 
 mitk::Geometry3D* mitk::WiiMoteInteractor::TransformCurrentDataInGeometry3D()
 {
   //checking corresponding Data; has to be a surface or a subclass
   mitk::Surface* surface = dynamic_cast<mitk::Surface*>(m_DataNode->GetData());
   if ( surface == NULL )
   {
     MITK_WARN<<"Wiimote Interactor got wrong type of data! Aborting interaction!\n";
     return NULL;
   }
-  Geometry3D* geometry = surface->GetUpdatedTimeSlicedGeometry()->GetGeometry3D( m_TimeStep );
+  Geometry3D* geometry = surface->GetUpdatedTimeGeometry()->GetGeometryForTimeStep( m_TimeStep );
   return geometry;
 }
 
 vnl_matrix_fixed<double, 4, 4> mitk::WiiMoteInteractor::ComputeCurrentCameraPosition( vtkCamera* vtkCamera )
 {
   vnl_matrix_fixed<double, 4, 4> cameraMat;
 
    //first we need the position of the camera
   mitk::Vector3D camPosition;
   double camPositionTemp[3];
   vtkCamera->GetPosition(camPositionTemp);
   camPosition[0] = camPositionTemp[0];
   camPosition[1] = camPositionTemp[1];
   camPosition[2] = camPositionTemp[2];
 
   //then the upvector of the camera
   mitk::Vector3D upCamVector;
   double upCamTemp[3];
   vtkCamera->GetViewUp(upCamTemp);
   upCamVector[0] = upCamTemp[0];
   upCamVector[1] = upCamTemp[1];
   upCamVector[2] = upCamTemp[2];
   upCamVector.Normalize();
 
   //then the vector to which the camera is heading at (focalpoint)
   mitk::Vector3D focalPoint;
   double focalPointTemp[3];
   vtkCamera->GetFocalPoint(focalPointTemp);
   focalPoint[0] = focalPointTemp[0];
   focalPoint[1] = focalPointTemp[1];
   focalPoint[2] = focalPointTemp[2];
   mitk::Vector3D focalVector;
   focalVector = focalPoint - camPosition;
   focalVector.Normalize();
 
   //orthogonal vector to focalVector and upCamVector
   mitk::Vector3D crossVector;
   crossVector = CrossProduct(upCamVector, focalVector);
   crossVector.Normalize();
 
   cameraMat.put(0,0,crossVector[0]);
   cameraMat.put(1,0,crossVector[1]);
   cameraMat.put(2,0,crossVector[2]);
   cameraMat.put(3,0,0);
 
   cameraMat.put(0,1,focalVector[0]);
   cameraMat.put(1,1,focalVector[1]);
   cameraMat.put(2,1,focalVector[2]);
   cameraMat.put(3,1,0);
 
   cameraMat.put(0,2,upCamVector[0]);
   cameraMat.put(1,2,upCamVector[1]);
   cameraMat.put(2,2,upCamVector[2]);
   cameraMat.put(3,2,0);
 
   cameraMat.put(0,3,camPosition[0]);
   cameraMat.put(1,3,camPosition[1]);
   cameraMat.put(2,3,camPosition[2]);
   cameraMat.put(3,3,1);
 
   return cameraMat;
 }
 
 bool mitk::WiiMoteInteractor::DynamicRotationAndTranslation(Geometry3D* geometry)
 {
    // computation of the delta transformation
   if(m_SurfaceInteractionMode == 1)
   {
     // necessary because the wiimote has
     // a different orientation when loaded
     // as an object file
     ScalarType temp = m_yAngle;
     m_yAngle = m_zAngle;
     m_zAngle = temp;
   }
 
   //vnl_quaternion<double> Rx(m_OrientationX
   //  ,m_OrientationY
   //  ,m_OrientationZ
   //  , m_xAngle);
 
   //vnl_quaternion<double> Ry(Rx.axis()[0]
   //  , Rx.axis()[1]
   //  , Rx.axis()[2]
   //  , m_yAngle);
 
   //vnl_quaternion<double> Rz(Ry.axis()[0]
   //  , Ry.axis()[1]
   //  , Ry.axis()[2]
   //  , m_zAngle);
 
 
   vnl_quaternion<double> q(
     vtkMath::RadiansFromDegrees( m_xAngle ),
     vtkMath::RadiansFromDegrees( m_yAngle ),
     vtkMath::RadiansFromDegrees( m_zAngle ) );
 
   //q = Rz * Ry * Rx;
   //q.normalize();
 
   vnl_matrix_fixed<double, 4, 4> deltaTransformMat = q.rotation_matrix_transpose_4();
 
   // fill translation column
   deltaTransformMat(0,3) = m_xVelocity;
   deltaTransformMat(1,3) = m_yVelocity;
   deltaTransformMat(2,3) = m_zVelocity;
 
   // invert matrix to apply
   // correct order for the transformation
   deltaTransformMat = vnl_inverse(deltaTransformMat);
 
   vtkMatrix4x4* deltaTransform = vtkMatrix4x4::New();
 
   // copy into matrix
   for(size_t i=0; i<4; ++i)
     for(size_t j=0; j<4; ++j)
       deltaTransform->SetElement(i,j, deltaTransformMat(i,j));
 
   vtkMatrix4x4* objectTransform = vtkMatrix4x4::New();
 
   if(m_SurfaceInteractionMode == 2)
   {
     // additional computation for transformation
     // relative to the camera view
 
     // get renderer
     const RenderingManager::RenderWindowVector& renderWindows
       = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
     for ( RenderingManager::RenderWindowVector::const_iterator iter = renderWindows.begin();
       iter != renderWindows.end();
       ++iter )
     {
       if ( mitk::BaseRenderer::GetInstance((*iter))->GetMapperID() == BaseRenderer::Standard3D )
       {
         m_BaseRenderer = mitk::BaseRenderer::GetInstance((*iter));
       }
     }
 
     vtkCamera* camera
       = m_BaseRenderer->GetVtkRenderer()->GetActiveCamera();
 
     //vtkMatrix4x4* cameraMat = vtkMatrix4x4::New();
     vnl_matrix_fixed<double, 4, 4> cameraMat;
     vnl_matrix_fixed<double, 4, 4> objectMat;
 
     // copy object matrix
     for(size_t i=0; i<4; ++i)
       for(size_t j=0; j<4; ++j)
         objectMat.put(i,j, geometry->GetVtkTransform()->GetMatrix()->GetElement(i,j));
 
     cameraMat = this->ComputeCurrentCameraPosition(camera);
 
     vnl_matrix_fixed<double, 4, 4> newObjectMat;
     vnl_matrix_fixed<double, 4, 4> objectToCameraMat;
 
     objectToCameraMat = vnl_inverse(cameraMat) * objectMat;
 
     newObjectMat = vnl_inverse(objectToCameraMat)
       * deltaTransformMat
       * objectToCameraMat
       * vnl_inverse(objectMat);
 
     newObjectMat = vnl_inverse(newObjectMat);
     newObjectMat.put(0,3,objectMat(0,3)+deltaTransformMat(0,3));
     newObjectMat.put(1,3,objectMat(1,3)+deltaTransformMat(1,3));
     newObjectMat.put(2,3,objectMat(2,3)+deltaTransformMat(2,3));
 
 
     // copy result
     for(size_t i=0; i<4; ++i)
       for(size_t j=0; j<4; ++j)
         objectTransform->SetElement(i,j, newObjectMat(i,j));
   }
 
   //copy m_vtkMatrix to m_VtkIndexToWorldTransform
   geometry->TransferItkToVtkTransform();
 
   vtkTransform* vtkTransform = vtkTransform::New();
 
   if(m_SurfaceInteractionMode == 1)
   {
     //m_VtkIndexToWorldTransform as vtkLinearTransform*
     vtkTransform->SetMatrix( geometry->GetVtkTransform()->GetMatrix() );
 
     vtkTransform->Concatenate( deltaTransform );
 
     geometry->SetIndexToWorldTransformByVtkMatrix( vtkTransform->GetMatrix() );
 
   }
   else
   {
     geometry->SetIndexToWorldTransformByVtkMatrix( objectTransform );
   }
 
   geometry->Modified();
   m_DataNode->Modified();
 
   vtkTransform->Delete();
   objectTransform->Delete();
 
   deltaTransform->Delete();
 
   //update rendering
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   return true;
 }
 
 
 bool mitk::WiiMoteInteractor::FixedRotationAndTranslation(const mitk::WiiMoteAllDataEvent* wiiMoteEvent)
 {
 
   Geometry3D* geometry = this->TransformCurrentDataInGeometry3D();
 
   m_OrientationX = wiiMoteEvent->GetOrientationX();
   m_OrientationY = wiiMoteEvent->GetOrientationY();
   m_OrientationZ = wiiMoteEvent->GetOrientationZ();
 
   ScalarType pitchSpeed = wiiMoteEvent->GetPitchSpeed();
   ScalarType rollSpeed = wiiMoteEvent->GetRollSpeed();
   ScalarType yawSpeed = wiiMoteEvent->GetYawSpeed();
 
   // angle x
   if(std::abs(pitchSpeed) < 200)
     pitchSpeed = 0;
 
   m_xAngle += (pitchSpeed / 1500);
 
   // angle y
   if(std::abs(rollSpeed) < 200)
     rollSpeed = 0;
 
   m_yAngle += (rollSpeed / 1500);
 
   // angle z
   if(std::abs(yawSpeed) < 200)
     yawSpeed = 0;
 
   m_zAngle += (yawSpeed / 1500);
 
   if(  std::abs(pitchSpeed) > 200
     || std::abs(rollSpeed) > 200
     || std::abs(yawSpeed) > 200)
   {
     m_InRotation = true;
     //// depending on a combination of the
     //// orientation the angleX wil be altered
     //// because the range from roll is limited
     //// range: -90° to 90° by the wiimote
     //if(wiiMoteEvent->GetOrientationZ() < 0)
     //{
     //  // value is positive
     //  if(wiiMoteEvent->GetOrientationX() > 0)
     //  {
     //    // the degree measured decreases after it reaches
     //    // in the "real" world the 90 degree angle
     //    // (rotation to the right side)
     //    // therefore it needs to artificially increased
 
     //    // measured value drops -> computated angle increases
     //    angleX = 90 - angleX;
 
     //    // now add the "new" angle to 90 degree threshold
     //    angleX += 90;
     //  }
     //  // value is negative
     //  else if(wiiMoteEvent->GetOrientationX() < 0)
     //  {
     //    // the degree measured increases after it reaches
     //    // in the "real" world -90 degree
     //    // (rotation to the left side)
     //    // therefore it needs to be artificially decreased
     //    // (example -90 -> -70, but -110 is needed)
 
     //    // measured value increases -> computated angle decreases
     //    angleX = 90 + angleX;
 
     //    // invert the algebraic sign, because it is the "negative"
     //    // side of the rotation
     //    angleX = -angleX;
 
     //    // now add the negative value to the -90 degree threshold
     //    // to decrease the value further
     //    angleX -= 90;
     //  }
     //  else if(wiiMoteEvent->GetOrientationX() == 0)
     //  {
     //    // i.e. wiimote is flipped upside down
     //    angleX = 180;
     //  }
     //}
 
     //rotation
     vtkTransform *vtkTransform = vtkTransform::New();
 
     //copy m_vtkMatrix to m_VtkIndexToWorldTransform
     geometry->TransferItkToVtkTransform();
 
     //////m_VtkIndexToWorldTransform as vtkLinearTransform*
     vtkTransform->SetMatrix(geometry->GetVtkTransform()->GetMatrix());
 
     // rotation from center is different
     // from rotation while translated
     // hence one needs the center of the object
     Point3D center = geometry->GetOrigin();
 
     vtkTransform->PostMultiply();
     vtkTransform->Translate(-center[0], -center[1], -center[2]);
     //vtkTransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
 
     vtkTransform->RotateX(m_xAngle);
 
     vtkTransform->RotateY(m_zAngle);
 
     vtkTransform->RotateZ(m_yAngle);
 
     vtkTransform->Translate(center[0], center[1], center[2]);
     vtkTransform->PreMultiply();
 
     geometry->SetIndexToWorldTransformByVtkMatrix(vtkTransform->GetMatrix());
     geometry->Modified();
 
     // indicate modification of data tree node
     m_DataNode->Modified();
 
     vtkTransform->Delete();
 
     //update rendering
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     return true;
 
   }
   else if(!m_InRotation)
   {
     float xValue = wiiMoteEvent->GetXAcceleration();
     float yValue = wiiMoteEvent->GetYAcceleration();
     float zValue = wiiMoteEvent->GetZAcceleration();
 
     float pitch = wiiMoteEvent->GetPitch();
     float roll = wiiMoteEvent->GetRoll();
 
     // substracts the proportionate force
     // applied by gravity depending on the
     // orientation
 
     float sinP = sin(pitch/180.0 * M_PI);
     float cosP = cos(pitch/180.0 * M_PI);
     float sinR = sin(roll/180.0 * M_PI);
     float cosR = cos(roll/180.0 * M_PI);
 
     // x acceleration
     if(m_OrientationZ >= 0)
       xValue = xValue - sinR * cosP;
     else
       xValue = xValue + sinR * cosP;
 
     // against drift
     if(std::abs(xValue) < 0.2)
       xValue = 0;
 
     // y acceleration
     yValue = yValue + sinP;
 
     // against drift
     if(std::abs(yValue) < 0.2)
       yValue = 0;
 
     // z acceleration
     zValue = zValue - cosP * cosR;
 
     // against drift
     if(std::abs(zValue) < 0.3)
       zValue = 0;
 
     // simple integration over time
     // resulting in velocity
     switch(m_TranslationMode)
     {
     case 1:
       m_xVelocity -= xValue;
       m_yVelocity -= yValue;
       m_zVelocity += zValue;
 
 
       // 1 = movement to the right
       // initially starts with negative acceleration
       // 2 = movement to the left
       // initially starts with positive acceleration
       if(  m_xVelocity > 0 && xValue > 0  // 1
         || m_xVelocity < 0 && xValue < 0) // 2
       {
         m_xVelocity += xValue;
       }
       else if( m_xVelocity > 0 && xValue < 0  // 1
         || m_xVelocity < 0 && xValue > 0)     // 2
       {
         m_xVelocity -= xValue;
       }
       break;
 
     case 3:
 
       m_yVelocity -= yValue;
       break;
     case 4:
 
       // 1 = movement up
       // initially starts with positive acceleration
       // 2 = movement down
       // initially starts with negative acceleration
       if(  m_zVelocity > 0 && zValue < 0  // 1
         || m_zVelocity < 0 && zValue > 0) // 2
       {
         m_zVelocity -= zValue;
       }
       else if(m_zVelocity > 0 && zValue > 0 // 1
         || m_zVelocity < 0 && zValue < 0)   // 2
       {
         m_zVelocity += zValue;
       }
       break;
     }
 
     // sets the mode of the translation
     // depending on the initial velocity
     if(  std::abs(m_xVelocity) > std::abs(m_yVelocity)
       && std::abs(m_xVelocity) > std::abs(m_zVelocity) )
     {
       m_TranslationMode = 2;
       m_yVelocity = 0;
       m_zVelocity = 0;
     }
     else if( std::abs(m_yVelocity) > std::abs(m_xVelocity)
       && std::abs(m_yVelocity) > std::abs(m_zVelocity) )
     {
       m_TranslationMode = 3;
       m_xVelocity = 0;
       m_zVelocity = 0;
     }
     else if(std::abs(m_zVelocity) > std::abs(m_xVelocity)
       && std::abs(m_zVelocity) > std::abs(m_yVelocity) )
     {
       m_TranslationMode = 4;
       m_xVelocity = 0;
       m_yVelocity = 0;
     }
 
     // translation
     mitk::Vector3D movementVector;
     movementVector.SetElement(0,m_xVelocity);
     movementVector.SetElement(1,m_yVelocity);
     movementVector.SetElement(2,m_zVelocity);
 
     geometry->Translate(movementVector);
 
     // indicate modification of data tree node
     m_DataNode->Modified();
 
     // update rendering
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     return true;
   }
 
   return false;
 }
diff --git a/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp b/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp
index 937e3a79a0..01cda35ab7 100644
--- a/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp
+++ b/Modules/IpPicSupport/Testing/mitkPicFileReaderTest.cpp
@@ -1,199 +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 "mitkTimeSlicedGeometry.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 (TimeSlicedGeometry expected): ";
-      mitk::TimeSlicedGeometry* timegeometry;
-      timegeometry = reader->GetOutput()->GetTimeSlicedGeometry();
-      if(timegeometry==NULL)
+      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 TimeSlicedGeometry: ";
-      if(timegeometry->GetGeometry3D(0)==NULL)
+      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 TimeSlicedGeometry (SlicedGeometry3D expected): ";
+      std::cout << "Testing type of first geometry contained in the TimeGeometry (SlicedGeometry3D expected): ";
       mitk::SlicedGeometry3D* slicedgeometry;
-      slicedgeometry = dynamic_cast<mitk::SlicedGeometry3D*>(timegeometry->GetGeometry3D(0));
+      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::Geometry2D* geometry2d = slicedgeometry->GetGeometry2D(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 extent in units of image of TimeSlicedGeometry: ";
-      if((fabs(timegeometry->GetExtent(0)-picheader->n[0])>mitk::eps) || (fabs(timegeometry->GetExtent(1)-picheader->n[1])>mitk::eps)
-        || (picheader->dim>2 && (fabs(timegeometry->GetExtent(2)-picheader->n[2])>mitk::eps))
-        || (picheader->dim>3 && (abs((mitkIpInt4_t) timegeometry->GetTimeSteps()- (mitkIpInt4_t) picheader->n[3])>0))
-        )
-      {
-        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/mitkPicFileReader.cpp b/Modules/IpPicSupport/mitkPicFileReader.cpp
index 3ba42ae077..3a021d419a 100644
--- a/Modules/IpPicSupport/mitkPicFileReader.cpp
+++ b/Modules/IpPicSupport/mitkPicFileReader.cpp
@@ -1,375 +1,375 @@
 /*===================================================================
 
 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 "mitkPicFileReader.h"
 #include "mitkPicHelper.h"
 #include <itkImageFileReader.h>
 #include "mitkImageWriteAccessor.h"
 
 extern "C"
 {
   mitkIpPicDescriptor * MITKipPicGet( char *infile_name, mitkIpPicDescriptor *pic );
   mitkIpPicDescriptor * MITKipPicGetTags( char *infile_name, mitkIpPicDescriptor *pic );
 }
 
 void mitk::PicFileReader::GenerateOutputInformation()
 {
     Image::Pointer output = this->GetOutput();
 
     if ((output->IsInitialized()) && (this->GetMTime() <= m_ReadHeaderTime.GetMTime()))
         return;
 
     itkDebugMacro(<<"Reading 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");
     }
 
     if( m_FileName != "")
     {
         mitkIpPicDescriptor* header=mitkIpPicGetHeader(const_cast<char *>(m_FileName.c_str()), NULL);
 
         if ( !header )
         {
             throw itk::ImageFileReaderException(__FILE__, __LINE__, "File could not be read.");
         }
 
         header=MITKipPicGetTags(const_cast<char *>(m_FileName.c_str()), header);
 
         int channels = 1;
 
         mitkIpPicTSV_t *tsv;
         if ( (tsv = mitkIpPicQueryTag( header, "SOURCE HEADER" )) != NULL)
         {
           if(tsv->n[0]>1e+06)
           {
             mitkIpPicTSV_t *tsvSH;
             tsvSH = mitkIpPicDelTag( header, "SOURCE HEADER" );
             mitkIpPicFreeTag(tsvSH);
           }
         }
         if ( (tsv = mitkIpPicQueryTag( header, "ICON80x80" )) != NULL)
         {
           mitkIpPicTSV_t *tsvSH;
           tsvSH = mitkIpPicDelTag( header, "ICON80x80" );
           mitkIpPicFreeTag(tsvSH);
         }
         if ( (tsv = mitkIpPicQueryTag( header, "VELOCITY" )) != NULL)
         {
           ++channels;
           mitkIpPicDelTag( header, "VELOCITY" );
         }
 
         if( header == NULL || header->bpe == 0)
         {
             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;
         }
 
         // if pic image only 2D, the n[2] value is not initialized
         unsigned int slices = 1;
         if( header->dim == 2 )
             header->n[2] = slices;
 
         // First initialize the geometry of the output image by the pic-header
         SlicedGeometry3D::Pointer slicedGeometry = mitk::SlicedGeometry3D::New();
         PicHelper::InitializeEvenlySpaced(header, header->n[2], slicedGeometry);
 
         // if pic image only 3D, the n[3] value is not initialized
         unsigned int timesteps = 1;
         if( header->dim > 3 )
             timesteps = header->n[3];
 
-        TimeSlicedGeometry::Pointer timeSliceGeometry = TimeSlicedGeometry::New();
-        timeSliceGeometry->InitializeEvenlyTimed(slicedGeometry, timesteps);
-        timeSliceGeometry->ImageGeometryOn();
+        slicedGeometry->ImageGeometryOn();
+        ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+        timeGeometry->Initialize(slicedGeometry, timesteps);
 
         // Cast the pic descriptor to ImageDescriptor and initialize the output
 
         output->Initialize( CastToImageDescriptor(header));
-        output->SetGeometry( timeSliceGeometry );
+        output->SetTimeGeometry( timeGeometry );
         mitkIpPicFree ( header );
     }
     else
     {
         int numberOfImages=0;
         m_StartFileIndex=0;
 
         mitkIpPicDescriptor* header=NULL;
 
         char fullName[1024];
 
         while(m_StartFileIndex<10)
         {
             sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+numberOfImages);
             FILE * f=fopen(fullName,"r");
             if(f==NULL)
             {
                 //already found an image?
                 if(numberOfImages>0)
                     break;
                 //no? let's increase start
                 ++m_StartFileIndex;
             }
             else
             {
                 fclose(f);
                 //only open the header of the first file found,
                 //@warning what to do when images do not have the same size??
                 if(header==NULL)
                 {
                     header=mitkIpPicGetHeader(fullName, NULL);
                     header=MITKipPicGetTags(fullName, header);
                 }
                 ++numberOfImages;
             }
         }
 
         printf("\n numberofimages %d\n",numberOfImages);
 
         if(numberOfImages==0)
         {
             itk::ImageFileReaderException e(__FILE__, __LINE__);
             std::ostringstream msg;
             msg << "no images found";
             e.SetDescription(msg.str().c_str());
             throw e;
             return;
         }
 
         //@FIXME: was ist, wenn die Bilder nicht alle gleich gross sind?
         if(numberOfImages>1)
         {
             printf("\n numberofimages %d > 1\n",numberOfImages);
             header->dim=3;
             header->n[2]=numberOfImages;
         }
 
         printf(" \ninitialisize output\n");
         output->Initialize( CastToImageDescriptor(header) );
         mitkIpPicFree ( header );
     }
 
     m_ReadHeaderTime.Modified();
 }
 
 void mitk::PicFileReader::ConvertHandedness(mitkIpPicDescriptor* pic)
 {
   //left to right handed conversion
   if(pic->dim>=3)
   {
       mitkIpPicDescriptor* slice=mitkIpPicCopyHeader(pic, NULL);
       slice->dim=2;
       size_t size=_mitkIpPicSize(slice);
       slice->data=malloc(size);
 
       size_t v, volumes = (pic->dim>3? pic->n[3] : 1);
       size_t volume_size = size*pic->n[2];
 
       for(v=0; v<volumes; ++v)
       {
         unsigned char *p_first=(unsigned char *)pic->data;
         unsigned char *p_last=(unsigned char *)pic->data;
         p_first+=v*volume_size;
         p_last+=size*(pic->n[2]-1)+v*volume_size;
 
         size_t i, smid=pic->n[2]/2;
         for(i=0; i<smid;++i,p_last-=size, p_first+=size)
         {
             memcpy(slice->data, p_last, size);
             memcpy(p_last, p_first, size);
             memcpy(p_first, slice->data, size);
         }
       }
       mitkIpPicFree(slice);
   }
 }
 
 void mitk::PicFileReader::GenerateData()
 {
     Image::Pointer output = this->GetOutput();
 
     // 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");
     }
 
     if( m_FileName != "")
     {
         mitkIpPicDescriptor* outputPic = mitkIpPicNew();
         mitk::ImageWriteAccessor imageAccess(output);
         outputPic = CastToIpPicDescriptor(output, &imageAccess, outputPic);
         mitkIpPicDescriptor* pic=MITKipPicGet(const_cast<char *>(m_FileName.c_str()),
                                               outputPic);
         // comes upside-down (in MITK coordinates) from PIC file
         ConvertHandedness(pic);
 
         mitkIpPicTSV_t *tsv;
         if ( (tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" )) != NULL)
         {
           if(tsv->n[0]>1e+06)
           {
             mitkIpPicTSV_t *tsvSH;
             tsvSH = mitkIpPicDelTag( pic, "SOURCE HEADER" );
             mitkIpPicFreeTag(tsvSH);
           }
         }
         if ( (tsv = mitkIpPicQueryTag( pic, "ICON80x80" )) != NULL)
         {
           mitkIpPicTSV_t *tsvSH;
           tsvSH = mitkIpPicDelTag( pic, "ICON80x80" );
           mitkIpPicFreeTag(tsvSH);
         }
         if ( (tsv = mitkIpPicQueryTag( pic, "VELOCITY" )) != NULL)
         {
           mitkIpPicDescriptor* header = mitkIpPicCopyHeader(pic, NULL);
           header->data = tsv->value;
           ConvertHandedness(header);
           output->SetChannel(header->data, 1);
           header->data = NULL;
           mitkIpPicFree(header);
           mitkIpPicDelTag( pic, "VELOCITY" );
         }
 
         //slice-wise reading
         //currently much too slow.
         //else
         //{
         //  int sstart, smax;
         //  int tstart, tmax;
 
         //  sstart=output->GetRequestedRegion().GetIndex(2);
         //  smax=sstart+output->GetRequestedRegion().GetSize(2);
 
         //  tstart=output->GetRequestedRegion().GetIndex(3);
         //  tmax=tstart+output->GetRequestedRegion().GetSize(3);
 
         //  int s,t;
         //  for(s=sstart; s<smax; ++s)
         //  {
         //    for(t=tstart; t<tmax; ++t)
         //    {
         //      mitkIpPicDescriptor* pic=mitkIpPicGetSlice(const_cast<char *>(m_FileName.c_str()), NULL, t*smax+s+1);
         //      output->SetPicSlice(pic,s,t);
         //    }
         //  }
         //}
     }
     else
     {
         int position;
         mitkIpPicDescriptor*  pic=NULL;
 
         int zDim=(output->GetDimension()>2?output->GetDimensions()[2]:1);
         printf("\n zdim is %u \n",zDim);
 
         for (position = 0; position < zDim; ++position)
         {
             char fullName[1024];
 
             sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+position);
 
             pic=MITKipPicGet(fullName, pic);
             if(pic==NULL)
             {
                 itkDebugMacro("Pic file '" << fullName << "' does not exist.");
             }
             /* FIXME else
             if(output->SetPicSlice(pic, position)==false)
             {
                 itkDebugMacro("Image '" << fullName << "' could not be added to Image.");
             }*/
        }
        if(pic!=NULL)
          mitkIpPicFree(pic);
     }
 }
 
 void mitk::PicFileReader::EnlargeOutputRequestedRegion(itk::DataObject *output)
 {
   output->SetRequestedRegionToLargestPossibleRegion();
 }
 
 bool mitk::PicFileReader::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;
   }
 
   // check if image is serie
   if( filePattern != "" && filePrefix != "" )
     return false;
 
   bool extensionFound = false;
   std::string::size_type PICPos = filename.rfind(".pic");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   PICPos = filename.rfind(".PIC");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   PICPos = filename.rfind(".pic.gz");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 7))
     {
     extensionFound = true;
     }
 
   PICPos = filename.rfind(".seq");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   if( !extensionFound )
     {
       //MITK_INFO<<"The filename extension is not recognized."<<std::endl;
     return false;
     }
 
   return true;
 }
 
 mitk::PicFileReader::PicFileReader()
     : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
 }
 
 mitk::PicFileReader::~PicFileReader()
 {
 }
diff --git a/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp b/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
index 83630cf126..a3868f58c6 100644
--- a/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
@@ -1,225 +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()->SetEvenlySpaced();
   //set the timebounds - after SetGeometry2D, 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());
 
-  output->GetTimeSlicedGeometry()->InitializeEvenlyTimed(output->GetSlicedGeometry(), output->GetTimeSlicedGeometry()->GetTimeSteps());
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(output->GetSlicedGeometry(),  output->GetTimeGeometry()->GetNumberOfTimeSteps());
+  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/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
index b1476eaa09..4659e37356 100644
--- a/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
@@ -1,236 +1,231 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if(_MSC_VER==1200)
 #include <itkFixedCenterOfRotationAffineTransform.h>
 #include <itkIndex.h>
 #include <itkConceptChecking.h>
 #endif
 #include "mitkBoundingObjectCutter.h"
 #include "mitkBoundingObjectCutter.txx"
 #include "mitkTimeHelper.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkBoundingObject.h"
 #include "mitkGeometry3D.h"
 #include <math.h>
 //#include "itkImageRegionIteratorWithIndex.h"
 
 namespace mitk
 {
 
 void BoundingObjectCutter::SetBoundingObject( const mitk::BoundingObject* boundingObject )
 {
   m_BoundingObject = const_cast<mitk::BoundingObject*>(boundingObject);
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(1,
     const_cast< mitk::BoundingObject * >( boundingObject ) );
 }
 
 const mitk::BoundingObject* BoundingObjectCutter::GetBoundingObject() const
 {
   return m_BoundingObject.GetPointer();
 }
 
 BoundingObjectCutter::BoundingObjectCutter()
   : m_BoundingObject(NULL), m_InsideValue(1), m_OutsideValue(0), m_AutoOutsideValue(false),
     m_UseInsideValue(false), m_OutsidePixelCount(0), m_InsidePixelCount(0), m_UseWholeInputRegion(false)
 {
   this->SetNumberOfIndexedInputs(2);
   this->SetNumberOfRequiredInputs(2);
   m_InputTimeSelector  = mitk::ImageTimeSelector::New();
   m_OutputTimeSelector = mitk::ImageTimeSelector::New();
 }
 
 BoundingObjectCutter::~BoundingObjectCutter()
 {
 }
 
 const mitk::PixelType BoundingObjectCutter::GetOutputPixelType()
 {
   return this->GetInput()->GetPixelType();
 }
 
 void BoundingObjectCutter::GenerateInputRequestedRegion()
 {
   mitk::Image* output = this->GetOutput();
-  if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
+  if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
     return;
   // we have already calculated the spatial part of the
   // input-requested-region in m_InputRequestedRegion in
   // GenerateOutputInformation (which is called before
   // GenerateInputRequestedRegion).
   GenerateTimeInInputRegion(output, const_cast< mitk::Image * > ( this->GetInput() ));
   GenerateTimeInInputRegion(output, m_BoundingObject.GetPointer());
 }
 
 void BoundingObjectCutter::GenerateOutputInformation()
 {
   mitk::Image::Pointer output = this->GetOutput();
   if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   mitk::Image::Pointer input = const_cast< mitk::Image * > ( this->GetInput() );
 
   if(input.IsNull())
   {
     MITK_WARN << "Input is not a mitk::Image";
     return;
   }
   itkDebugMacro(<<"GenerateOutputInformation()");
   unsigned int dimension = input->GetDimension();
 
   if (dimension < 3)
   {
     MITK_WARN << "ImageCropper cannot handle 1D or 2D Objects. Operation aborted.";
     return;
   }
 
-  if((m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
+  if((m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
     return;
 
   mitk::Geometry3D* boGeometry =  m_BoundingObject->GetGeometry();
   mitk::Geometry3D* inputImageGeometry = input->GetSlicedGeometry();
   // calculate bounding box of bounding-object relative to the geometry
   // of the input image. The result is in pixel coordinates of the input
   // image (because the m_IndexToWorldTransform includes the spacing).
   mitk::BoundingBox::Pointer boBoxRelativeToImage = boGeometry->CalculateBoundingBoxRelativeToTransform( inputImageGeometry->GetIndexToWorldTransform() );
 
   // 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 bounding-box of bounding-object
   mitk::SlicedData::IndexType  index=m_InputRequestedRegion.GetIndex(); //init times and channels
   mitk::BoundingBox::PointType min = boBoxRelativeToImage->GetMinimum();
   index[0] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[0]));
   index[1] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[1]));
   index[2] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[2]));
 
   mitk::SlicedData::SizeType   size = m_InputRequestedRegion.GetSize(); //init times and channels
   mitk::BoundingBox::PointType max = boBoxRelativeToImage->GetMaximum();
   size[0] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[0])-index[0]);
   size[1] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[1])-index[1]);
   size[2] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[2])-index[2]);
 
   mitk::SlicedData::RegionType boRegion(index, size);
 
   if(m_UseWholeInputRegion == false)
   {
     // crop input-requested-region with region of bounding-object
     if(m_InputRequestedRegion.Crop(boRegion)==false)
     {
     // crop not possible => do nothing: set time size to 0.
     size.Fill(0);
     m_InputRequestedRegion.SetSize(size);
     boRegion.SetSize(size);
     m_BoundingObject->SetRequestedRegion(&boRegion);
     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 *dimensions = new unsigned int [dimension];
   itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
   if(dimension>3)
     memcpy(dimensions+3, input->GetDimensions()+3, (dimension-3)*sizeof(unsigned int));
   output->Initialize(mitk::PixelType(GetOutputPixelType()), dimension, dimensions);
   delete [] dimensions;
 
   // now we have everything to initialize the transform of the output
   mitk::SlicedGeometry3D* slicedGeometry = output->GetSlicedGeometry();
 
   // set the transform: use the transform of the input;
   // the origin will be replaced afterwards
   AffineTransform3D::Pointer indexToWorldTransform = AffineTransform3D::New();
   indexToWorldTransform->SetParameters(input->GetSlicedGeometry()->GetIndexToWorldTransform()->GetParameters());
   slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
 
   // Position the output Image to match the corresponding region of the input image
   const mitk::SlicedData::IndexType& start = m_InputRequestedRegion.GetIndex();
   mitk::Point3D origin; vtk2itk(start, origin);
   inputImageGeometry->IndexToWorld(origin, origin);
   slicedGeometry->SetOrigin(origin);
 
-  mitk::TimeSlicedGeometry* timeSlicedGeometry = output->GetTimeSlicedGeometry();
-  timeSlicedGeometry->InitializeEvenlyTimed(slicedGeometry, output->GetDimension(3));
-  timeSlicedGeometry->CopyTimes(input->GetTimeSlicedGeometry());
-
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void BoundingObjectCutter::ComputeData(mitk::Image* input3D, int boTimeStep)
 {
   AccessFixedDimensionByItk_2(input3D, CutImage, 3, this, boTimeStep);
 }
 
 void BoundingObjectCutter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if(input.IsNull())
     return;
 
-  if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
+  if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
     return;
 
   m_InputTimeSelector->SetInput(input);
   m_OutputTimeSelector->SetInput(this->GetOutput());
 
   mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
-  const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *boundingObjectTimeGeometry = m_BoundingObject->GetTimeSlicedGeometry();
-  ScalarType timeInMS;
+  const mitk::TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
+  const mitk::TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
+  const mitk::TimeGeometry *boundingObjectTimeGeometry = m_BoundingObject->GetTimeGeometry();
+  TimePointType 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->TimeStepToMS( t );
-
-    timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
+    timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
+    timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
 
     m_InputTimeSelector->SetTimeNr(timestep);
     m_InputTimeSelector->UpdateLargestPossibleRegion();
     m_OutputTimeSelector->SetTimeNr(t);
     m_OutputTimeSelector->UpdateLargestPossibleRegion();
 
-    timestep = boundingObjectTimeGeometry->MSToTimeStep( timeInMS );
+    timestep = boundingObjectTimeGeometry->TimePointToTimeStep( timeInMS );
 
     ComputeData(m_InputTimeSelector->GetOutput(), timestep);
   }
 
   m_InputTimeSelector->SetInput(NULL);
   m_OutputTimeSelector->SetInput(NULL);
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 } // of namespace mitk
diff --git a/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp b/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
index 78defa2e6b..230f1bf9a7 100644
--- a/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
@@ -1,498 +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 <ipPic/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.
   //@fixme!!! will not work for not evenly timed data!
   output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
-  output->GetTimeSlicedGeometry()->InitializeEvenlyTimed(output->GetSlicedGeometry(), output->GetTimeSlicedGeometry()->GetTimeSteps());
 
-  output->SetPropertyList(input->GetPropertyList()->Clone());
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(output->GetSlicedGeometry(), output->GetTimeGeometry()->GetNumberOfTimeSteps());
+  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/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp
index fb35a8e338..dcce736a30 100644
--- a/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp
@@ -1,253 +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::Geometry3D* aClippingGeometry)
 {
   if(aClippingGeometry != m_ClippingGeometry.GetPointer())
   {
     m_ClippingGeometry = aClippingGeometry;
-    m_TimeSlicedClippingGeometry = dynamic_cast<const TimeSlicedGeometry*>(aClippingGeometry);
     m_ClippingGeometryData->SetGeometry(const_cast<mitk::Geometry3D*>(aClippingGeometry));
     SetNthInput(1, m_ClippingGeometryData);
     Modified();
   }
 }
 
 const mitk::Geometry3D* 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::Geometry3D*>(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::Geometry2D* clippingGeometry2D)
 {
   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::Geometry3D* 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)
       {
       // 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 ( 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 Geometry2D * clippingGeometryOfCurrentTimeStep = NULL;
 
-  if(m_TimeSlicedClippingGeometry.IsNull())
+  if(m_TimeClippingGeometry.IsNull())
   {
     clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(m_ClippingGeometry.GetPointer());
   }
   else
   {
-    clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(m_TimeSlicedClippingGeometry->GetGeometry3D(0));
+    clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(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::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
+  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->TimeStepToMS( t );
-
-    timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
+    timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
+    timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
 
     m_InputTimeSelector->SetTimeNr(timestep);
     m_InputTimeSelector->UpdateLargestPossibleRegion();
     m_OutputTimeSelector->SetTimeNr(t);
     m_OutputTimeSelector->UpdateLargestPossibleRegion();
 
-    if(m_TimeSlicedClippingGeometry.IsNotNull())
+    if(m_TimeClippingGeometry.IsNotNull())
     {
-      timestep = m_TimeSlicedClippingGeometry->MSToTimeStep( timeInMS );
-      if(m_TimeSlicedClippingGeometry->IsValidTime(timestep) == false)
+      timestep = m_TimeClippingGeometry->TimePointToTimeStep( timeInMS );
+      if(m_TimeClippingGeometry->IsValidTimeStep(timestep) == false)
         continue;
 
-      clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(m_TimeSlicedClippingGeometry->GetGeometry3D(timestep));
+      clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(m_TimeClippingGeometry->GetGeometryForTimeStep(timestep).GetPointer());
     }
 
     AccessByItk_2(m_InputTimeSelector->GetOutput(),_InternalComputeClippedImage,this,clippingGeometryOfCurrentTimeStep);
   }
 
   m_TimeOfHeaderInitialization.Modified();
 }
diff --git a/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.h b/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.h
index d415d38303..cb8eecb492 100644
--- a/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.h
+++ b/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.h
@@ -1,172 +1,182 @@
 /*===================================================================
 
 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 "MitkExtExports.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 Geometry2D
 //##
 //## The given geometry for clipping can be either a Geometry2D
-//## or a TimeSlicedGeometry containing multiple instances
+//## or a TimeGeometry containing multiple instances
 //## of Geometry2D
 //##
 //## \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 MitkExt_EXPORT GeometryClipImageFilter : public ImageToImageFilter
 {
 public:
   mitkClassMacro(GeometryClipImageFilter, ImageToImageFilter);
 
   itkNewMacro(Self);
 
-  //##Description
-  //## Set the geometry to be used for clipping
-  //##
-  //## The given geometry for clipping can be either a Geometry2D
-  //## or a TimeSlicedGeometry containing multiple instances
-  //## of Geometry2D
+  /**
+  * Set the geometry to be used for clipping
+  *
+  * The given geometry for clipping must be a Geometry2D.
+  */
   void SetClippingGeometry(const mitk::Geometry3D* aClippingGeometry);
+
+  /**
+  * Set the geometry to be used for clipping
+  *
+  * The given geometry for clipping must a
+  * TimeGeometry containing multiple instances
+  * of Geometry2D
+  */
+  void SetClippingGeometry(const mitk::TimeGeometry* aClippingGeometry);
+
   const mitk::Geometry3D* 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::Geometry2D* clippingGeometry2D);
 
   mitk::Geometry3D::ConstPointer m_ClippingGeometry;
   mitk::GeometryData::Pointer m_ClippingGeometryData;
-  mitk::TimeSlicedGeometry::ConstPointer m_TimeSlicedClippingGeometry;
+  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/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp
index 55502a4ff6..1bae90c3bc 100644
--- a/Modules/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp
@@ -1,471 +1,471 @@
 /*===================================================================
 
 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 "mitkHeightFieldSurfaceClipImageFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkTimeHelper.h"
 #include "mitkProperties.h"
 
 #include "mitkImageToItk.h"
 #include "mitkImageAccessByItk.h"
 
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkImageSliceConstIteratorWithIndex.h>
 
 #include <vtkPolyData.h>
 #include <vtkCellLocator.h>
 
 #include <limits>
 
 
 namespace mitk
 {
 
   HeightFieldSurfaceClipImageFilter::HeightFieldSurfaceClipImageFilter()
     : m_ClippingMode( CLIPPING_MODE_CONSTANT ),
     m_ClippingConstant( 0.0 ),
     m_MultiplicationFactor( 2.0 ),
     m_HeightFieldResolutionX( 256 ),
     m_HeightFieldResolutionY( 256 ),
     m_MaxHeight( 1024.0 ),
     m_MultiPlaneValue(2)
   {
     this->SetNumberOfIndexedInputs(8);
     this->SetNumberOfRequiredInputs(2);
 
     m_InputTimeSelector = ImageTimeSelector::New();
     m_OutputTimeSelector = ImageTimeSelector::New();
   }
 
 
   HeightFieldSurfaceClipImageFilter::~HeightFieldSurfaceClipImageFilter()
   {
   }
 
 
   void HeightFieldSurfaceClipImageFilter::SetClippingSurface(
     Surface *clippingSurface )
   {
     this->SetNthInput( 1, clippingSurface );
   }
 
   void HeightFieldSurfaceClipImageFilter::SetClippingSurfaces(ClippingPlaneList planeList)
   {
     if(planeList.size() > 7)
     {
       MITK_WARN<<"Only 7 clipping planes are allowed!";
     }
 
     for (unsigned int i = 0; i < planeList.size(); ++i)
     {
       this->SetNthInput(i+1, planeList.at(i));
     }
   }
 
 
   const Surface* HeightFieldSurfaceClipImageFilter::GetClippingSurface() const
   {
     return dynamic_cast< const Surface * >( itk::ProcessObject::GetInput( 1 ) );
   }
 
 
   void HeightFieldSurfaceClipImageFilter::SetClippingMode( int mode )
   {
     m_ClippingMode = mode;
   }
 
 
   int HeightFieldSurfaceClipImageFilter::GetClippingMode()
   {
     return m_ClippingMode;
   }
 
 
   void HeightFieldSurfaceClipImageFilter::SetClippingModeToConstant()
   {
     m_ClippingMode = CLIPPING_MODE_CONSTANT;
   }
 
 
   void HeightFieldSurfaceClipImageFilter::SetClippingModeToMultiplyByFactor()
   {
     m_ClippingMode = CLIPPING_MODE_MULTIPLYBYFACTOR;
   }
 
   void HeightFieldSurfaceClipImageFilter::SetClippingModeToMultiPlaneValue()
   {
     m_ClippingMode = CLIPPING_MODE_MULTIPLANE;
   }
 
   void HeightFieldSurfaceClipImageFilter::GenerateInputRequestedRegion()
   {
     Image *outputImage = this->GetOutput();
     Image *inputImage = const_cast< Image * >( this->GetInput( 0 ) );
     const Surface *inputSurface = dynamic_cast< const Surface * >( this->GetInput( 1 ) );
 
     if ( !outputImage->IsInitialized() || inputSurface == NULL )
     {
       return;
     }
 
     inputImage->SetRequestedRegionToLargestPossibleRegion();
 
     GenerateTimeInInputRegion( outputImage, inputImage );
   }
 
 
   void HeightFieldSurfaceClipImageFilter::GenerateOutputInformation()
   {
     const Image *inputImage = this->GetInput( 0 );
     Image *outputImage = this->GetOutput();
 
     if ( outputImage->IsInitialized()
       && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()) )
     {
       return;
     }
 
     itkDebugMacro(<<"GenerateOutputInformation()");
 
     unsigned int i;
     unsigned int *tmpDimensions = new unsigned int[inputImage->GetDimension()];
 
     for ( i = 0; i < inputImage->GetDimension(); ++i )
     {
       tmpDimensions[i] = inputImage->GetDimension( i );
     }
 
     outputImage->Initialize( inputImage->GetPixelType(),
       inputImage->GetDimension(),
       tmpDimensions,
       inputImage->GetNumberOfChannels() );
 
     delete[] tmpDimensions;
 
     outputImage->SetGeometry(
       static_cast< Geometry3D * >( inputImage->GetGeometry()->Clone().GetPointer() ) );
 
     outputImage->SetPropertyList( inputImage->GetPropertyList()->Clone() );
 
     m_TimeOfHeaderInitialization.Modified();
   }
 
 
   template < typename TPixel, unsigned int VImageDimension >
   void HeightFieldSurfaceClipImageFilter::_InternalComputeClippedImage(
     itk::Image< TPixel, VImageDimension > *inputItkImage,
     HeightFieldSurfaceClipImageFilter *clipImageFilter,
     vtkPolyData *clippingPolyData,
     AffineTransform3D *imageToPlaneTransform )
   {
     typedef itk::Image< TPixel, VImageDimension > ItkInputImageType;
     typedef itk::Image< TPixel, VImageDimension > ItkOutputImageType;
 
     typedef itk::ImageSliceConstIteratorWithIndex< ItkInputImageType > ItkInputImageIteratorType;
     typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
 
     typename ImageToItk<ItkOutputImageType >::Pointer outputimagetoitk =
       ImageToItk<ItkOutputImageType>::New();
     outputimagetoitk->SetInput( clipImageFilter->m_OutputTimeSelector->GetOutput() );
     outputimagetoitk->Update();
 
     typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
                     std::vector< double > test;
 
 
     // create the iterators
     typename ItkInputImageType::RegionType inputRegionOfInterest =
       inputItkImage->GetLargestPossibleRegion();
     ItkInputImageIteratorType  inputIt( inputItkImage, inputRegionOfInterest );
     ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
 
     // Get bounds of clipping data
     clippingPolyData->ComputeBounds();
     vtkFloatingPointType *bounds = clippingPolyData->GetBounds();
 
     double xWidth = bounds[1] - bounds[0];
     double yWidth = bounds[3] - bounds[2];
 
     // Create vtkCellLocator for clipping poly data
     vtkCellLocator *cellLocator = vtkCellLocator::New();
     cellLocator->SetDataSet( clippingPolyData );
     cellLocator->CacheCellBoundsOn();
     cellLocator->AutomaticOn();
     cellLocator->BuildLocator();
 
     // Allocate memory for 2D image to hold the height field generated by
     // projecting the clipping data onto the plane
     double *heightField = new double[m_HeightFieldResolutionX * m_HeightFieldResolutionY];
 
     // Walk through height field and for each entry calculate height of the
     // clipping poly data at this point by means of vtkCellLocator. The
     // clipping data x/y bounds are used for converting from poly data space to
     // image (height-field) space.
     MITK_INFO << "Calculating Height Field..." << std::endl;
     for ( unsigned int y = 0; y < m_HeightFieldResolutionY; ++y )
     {
       for ( unsigned int x = 0; x < m_HeightFieldResolutionX; ++x )
       {
         vtkFloatingPointType p0[3], p1[3], surfacePoint[3], pcoords[3];
         p0[0] = bounds[0] + xWidth * x / (double) m_HeightFieldResolutionX;
         p0[1] = bounds[2] + yWidth * y / (double) m_HeightFieldResolutionY;
         p0[2] = -m_MaxHeight;
 
         p1[0] = p0[0];
         p1[1] = p0[1];
         p1[2] = m_MaxHeight;
 
         double t, distance;
         int subId;
         if ( cellLocator->IntersectWithLine( p0, p1, 0.1, t, surfacePoint, pcoords, subId ) )
         {
           distance = (2.0 * t - 1.0) * m_MaxHeight;
         }
         else
         {
           distance = -65536.0;
         }
         heightField[y * m_HeightFieldResolutionX + x] = distance;
         itk::Image<double,2>::IndexType index;
         index[0] = x;
         index[1] = y;
       }
     }
 
 
     // Walk through entire input image and for each point determine its distance
     // from the x/y plane.
     MITK_INFO << "Performing clipping..." << std::endl;
 
     TPixel factor = static_cast< TPixel >( clipImageFilter->m_MultiplicationFactor );
     TPixel clippingConstant = clipImageFilter->m_ClippingConstant;
 
     inputIt.SetFirstDirection( 0 );
     inputIt.SetSecondDirection( 1 );
     //through all slices
     for ( inputIt.GoToBegin(), outputIt.GoToBegin();
       !inputIt.IsAtEnd();
       inputIt.NextSlice() )
     {
       //through all lines of a slice
       for ( ; !inputIt.IsAtEndOfSlice(); inputIt.NextLine() )
       {
         //Transform the start(line) point from the image to the plane
         Point3D imageP0, planeP0;
         imageP0[0] = inputIt.GetIndex()[0];
         imageP0[1] = inputIt.GetIndex()[1];
         imageP0[2] = inputIt.GetIndex()[2];
         planeP0 = imageToPlaneTransform->TransformPoint( imageP0 );
 
         //Transform the end point (line) from the image to the plane
         Point3D imageP1, planeP1;
         imageP1[0] = imageP0[0] + inputRegionOfInterest.GetSize( 0 );
         imageP1[1] = imageP0[1];
         imageP1[2] = imageP0[2];
         planeP1 = imageToPlaneTransform->TransformPoint( imageP1 );
 
         //calculate the step size (if the plane is rotate, you go "crossway" through the image)
         Vector3D step = (planeP1 - planeP0) / (double) inputRegionOfInterest.GetSize( 0 );
 
         //over all pixel
         for ( ; !inputIt.IsAtEndOfLine(); ++inputIt, ++outputIt, planeP0 += step )
         {
           //Only ConstantMode: if image pixel value == constant mode value-->set output pixel value directly
           if ( (clipImageFilter->m_ClippingMode == CLIPPING_MODE_CONSTANT)
             && ((TPixel)inputIt.Get() == clippingConstant ) )
           {
             outputIt.Set( clippingConstant );
           }
 
           else
           {
             int x0 = (int) ((double)(m_HeightFieldResolutionX) * (planeP0[0] - bounds[0]) / xWidth);
             int y0 = (int) ((double)(m_HeightFieldResolutionY) * (planeP0[1] - bounds[2]) / yWidth);
 
             bool clip;
 
             //if the current point is outside of the plane region (RegionOfInterest)-->clip the pixel allways
             if ( (x0 < 0) || (x0 >= (int)m_HeightFieldResolutionX)
               || (y0 < 0) || (y0 >= (int)m_HeightFieldResolutionY) )
             {
               clip = true;
             }
 
             else
             {
               // Calculate bilinearly interpolated height field value at plane point
               int x1 = x0 + 1;
               int y1 = y0 + 1;
               if ( x1 >= (int)m_HeightFieldResolutionX ) { x1 = x0; }
               if ( y1 >= (int)m_HeightFieldResolutionY ) { y1 = y0; }
 
               //Get the neighbour points for the interpolation
               ScalarType q00, q01, q10, q11;
               q00 = heightField[y0 * m_HeightFieldResolutionX + x0];
               q01 = heightField[y0 * m_HeightFieldResolutionX + x1];
               q10 = heightField[y1 * m_HeightFieldResolutionX + x0];
               q11 = heightField[y1 * m_HeightFieldResolutionX + x1];
 
               /*
               !!!!!The bilinear interpolation doesn't work at the moment: If the plane is deformed there are some strange artefacts!!!
               The problem is the scaling of the planeP0 and the x/y values
 
               ScalarType q =
               q00 * ((double) x1 - planeP0[0]) * ((double) y1 - planeP0[1])
               + q01 * (planeP0[0] - (double) x0) * ((double) y1 - planeP0[1])
               + q10 * ((double) x1 - planeP0[0]) * (planeP0[1] - (double) y0)
               + q11 * (planeP0[0] - (double) x0) * (planeP0[1] - (double) y0);
               */
 
               //ATM: set the value direct, without interpolation: stepped view (only by the deformed plane)
               ScalarType q = heightField[y0 * m_HeightFieldResolutionX + x0];
 
               //decide, whether the point is on the one side of the plane or on the other
               if ( q - planeP0[2] < 0 )
               {
                 clip = true;
               }
               else
               {
                 clip = false;
               }
             }
 
             //different modes: differnt values for the clipped pixel
             if ( clip )
             {
               if ( clipImageFilter->m_ClippingMode == CLIPPING_MODE_CONSTANT )
               {
                 outputIt.Set( clipImageFilter->m_ClippingConstant );
               }
               else if ( clipImageFilter->m_ClippingMode == CLIPPING_MODE_MULTIPLYBYFACTOR )
               {
                 outputIt.Set( inputIt.Get() * factor );
               }
               else if ( clipImageFilter->m_ClippingMode == CLIPPING_MODE_MULTIPLANE )
               {
                 if(inputIt.Get() != 0)
                   outputIt.Set( inputIt.Get() + m_MultiPlaneValue);
                 else
                   outputIt.Set( inputIt.Get() );
               }
             }
             // the non-clipped pixel keeps his value
             else
             {
               outputIt.Set( inputIt.Get() );
             }
           }
         }
       }
     }
 
     MITK_INFO << "DONE!" << std::endl;
 
     // Clean-up
     cellLocator->Delete();
   }
 
 
   void HeightFieldSurfaceClipImageFilter::GenerateData()
   {
     const Image *inputImage = this->GetInput( 0 );
 
     const Image *outputImage = this->GetOutput();
 
     m_InputTimeSelector->SetInput( inputImage );
     m_OutputTimeSelector->SetInput( outputImage );
 
     Image::RegionType outputRegion = outputImage->GetRequestedRegion();
-    const TimeSlicedGeometry *outputTimeGeometry = outputImage->GetTimeSlicedGeometry();
-    const TimeSlicedGeometry *inputTimeGeometry = inputImage->GetTimeSlicedGeometry();
+    const TimeGeometry *outputTimeGeometry = outputImage->GetTimeGeometry();
+    const TimeGeometry *inputTimeGeometry = inputImage->GetTimeGeometry();
     ScalarType timeInMS;
 
     int timestep = 0;
     int tstart = outputRegion.GetIndex( 3 );
     int tmax = tstart + outputRegion.GetSize( 3 );
 
     for (unsigned int i = 1; i < this->GetNumberOfInputs(); ++i)
     {
       Surface *inputSurface = const_cast< Surface * >(
         dynamic_cast< Surface * >( itk::ProcessObject::GetInput( i ) ) );
 
       if ( !outputImage->IsInitialized() || inputSurface == NULL )
         return;
 
       MITK_INFO<<"Plane: "<<i;
       MITK_INFO << "Clipping: Start\n";
 
       //const Geometry2D *clippingGeometryOfCurrentTimeStep = NULL;
 
       int t;
       for( t = tstart; t < tmax; ++t )
       {
-        timeInMS = outputTimeGeometry->TimeStepToMS( t );
-        timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
+        timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
+        timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
 
         m_InputTimeSelector->SetTimeNr( timestep );
         m_InputTimeSelector->UpdateLargestPossibleRegion();
         m_OutputTimeSelector->SetTimeNr( t );
         m_OutputTimeSelector->UpdateLargestPossibleRegion();
 
         // Compose IndexToWorld transform of image with WorldToIndexTransform of
         // clipping data for conversion from image index space to plane index space
         AffineTransform3D::Pointer planeWorldToIndexTransform = AffineTransform3D::New();
         inputSurface->GetGeometry( t )->GetIndexToWorldTransform()
           ->GetInverse( planeWorldToIndexTransform );
 
         AffineTransform3D::Pointer imageToPlaneTransform =
           AffineTransform3D::New();
         imageToPlaneTransform->SetIdentity();
 
         imageToPlaneTransform->Compose(
-          inputTimeGeometry->GetGeometry3D( t )->GetIndexToWorldTransform() );
+          inputTimeGeometry->GetGeometryForTimeStep( t )->GetIndexToWorldTransform() );
         imageToPlaneTransform->Compose( planeWorldToIndexTransform );
 
         MITK_INFO << "Accessing ITK function...\n";
         if(i==1)
         {
           AccessByItk_3(
             m_InputTimeSelector->GetOutput(),
             _InternalComputeClippedImage,
             this,
             inputSurface->GetVtkPolyData( t ),
             imageToPlaneTransform );
         }
         else
         {
           mitk::Image::Pointer extensionImage = m_OutputTimeSelector->GetOutput()->Clone();
           AccessByItk_3(
             extensionImage,
             _InternalComputeClippedImage,
             this,
             inputSurface->GetVtkPolyData( t ),
             imageToPlaneTransform );
         }
         if (m_ClippingMode == CLIPPING_MODE_MULTIPLANE)
           m_MultiPlaneValue = m_MultiPlaneValue*2;
       }
     }
 
 
 
     m_TimeOfHeaderInitialization.Modified();
   }
 
 } // namespace
diff --git a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
index 1775573d36..fec0fc43c4 100644
--- a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
@@ -1,364 +1,365 @@
 /*===================================================================
 
 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 <mitkLabeledImageToSurfaceFilter.h>
 
 #include <vtkImageChangeInformation.h>
 #include <vtkImageThreshold.h>
 #include <vtkImageGaussianSmooth.h>
 #include <vtkImageMarchingCubes.h>
 #include <vtkPolyData.h>
 #include <vtkSmoothPolyDataFilter.h>
 #include <vtkDecimatePro.h>
 #include <vtkLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 #include <mitkImageAccessByItk.h>
 #include <mitkInstantiateAccessFunctions.h>
 #include <itkImageRegionIterator.h>
 #include <itkNumericTraits.h>
 
 
 mitk::LabeledImageToSurfaceFilter::LabeledImageToSurfaceFilter() :
 m_GaussianStandardDeviation(1.5),
 m_GenerateAllLabels(true),
 m_Label(1),
 m_BackgroundLabel(0)
 {
 }
 
 mitk::LabeledImageToSurfaceFilter::~LabeledImageToSurfaceFilter()
 {
 }
 
 void mitk::LabeledImageToSurfaceFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
   //
   // check which labels are available in the image
   //
   m_AvailableLabels = this->GetAvailableLabels();
   m_IdxToLabels.clear();
 
   //
   // if we don't want to generate surfaces for all labels
   // we have to remove all labels except m_Label and m_BackgroundLabel
   // from the list of available labels
   //
   if ( ! m_GenerateAllLabels )
   {
     LabelMapType tmp;
     LabelMapType::iterator it;
     it = m_AvailableLabels.find( m_Label );
     if ( it != m_AvailableLabels.end() )
       tmp[m_Label] = it->second;
     else
       tmp[m_Label] = 0;
 
     it = m_AvailableLabels.find( m_BackgroundLabel );
     if ( it != m_AvailableLabels.end() )
       tmp[m_BackgroundLabel] = it->second;
     else
       tmp[m_BackgroundLabel] = 0;
 
     m_AvailableLabels = tmp;
   }
 
   //
   // check for the number of labels: if the whole image is filled, no
   // background is available and thus the numberOfOutpus is equal to the
   // number of available labels in the image (which is a special case).
   // If we have background voxels, the number of outputs is one less than
   // then number of available labels.
   //
   unsigned int numberOfOutputs = 0;
   if ( m_AvailableLabels.find( m_BackgroundLabel ) == m_AvailableLabels.end() )
     numberOfOutputs = m_AvailableLabels.size();
   else
     numberOfOutputs = m_AvailableLabels.size() - 1;
   if ( numberOfOutputs == 0 )
   {
     itkWarningMacro("Number of outputs == 0");
   }
 
   //
   // determine the number of time steps of the input image
   //
   mitk::Image* image =  ( mitk::Image* )GetInput();
-  unsigned int numberOfTimeSteps = image->GetTimeSlicedGeometry()->GetTimeSteps();
+
+  unsigned int numberOfTimeSteps = image->GetTimeGeometry()->GetNumberOfTimeSteps();
 
   //
   // set the number of outputs to the number of labels used.
   // initialize the output surfaces accordingly (incl. time steps)
   //
   this->SetNumberOfIndexedOutputs( numberOfOutputs );
   this->SetNumberOfRequiredOutputs( numberOfOutputs );
   for ( unsigned int i = 0 ; i < numberOfOutputs; ++i )
   {
     if ( ! this->GetOutput( i ) )
     {
       mitk::Surface::Pointer output = static_cast<mitk::Surface*>( this->MakeOutput(0).GetPointer() );
       assert ( output.IsNotNull() );
       output->Expand( numberOfTimeSteps );
       this->SetNthOutput( i, output.GetPointer() );
     }
   }
 }
 
 
 void mitk::LabeledImageToSurfaceFilter::GenerateData()
 {
   mitk::Image* image =  ( mitk::Image* )GetInput();
   if ( image == NULL )
   {
     itkWarningMacro("Image is NULL");
     return;
   }
 
   mitk::Image::RegionType outputRegion = image->GetRequestedRegion();
 
   m_IdxToLabels.clear();
 
   if ( this->GetNumberOfOutputs() == 0 )
     return;
 
   //
   // traverse the known labels and create surfaces for them.
   //
   unsigned int currentOutputIndex = 0;
   for ( LabelMapType::iterator it = m_AvailableLabels.begin() ; it != m_AvailableLabels.end() ; ++it )
   {
     if ( it->first == m_BackgroundLabel )
       continue;
     if ( ( it->second == 0 ) && m_GenerateAllLabels )
       continue;
 
     assert ( currentOutputIndex < this->GetNumberOfOutputs() );
     mitk::Surface::Pointer surface = this->GetOutput( currentOutputIndex );
     assert( surface.IsNotNull() );
 
     int tstart=outputRegion.GetIndex(3);
     int tmax=tstart+outputRegion.GetSize(3); //GetSize()==1 - will aber 0 haben, wenn nicht zeitaufgeloet
     int t;
     for( t=tstart; t < tmax; ++t)
     {
       vtkImageData *vtkimagedata =  image->GetVtkImageData( t );
       CreateSurface( t,vtkimagedata,surface.GetPointer(), it->first );
     }
     m_IdxToLabels[ currentOutputIndex ] = it->first;
     currentOutputIndex++;
   }
 }
 
 void mitk::LabeledImageToSurfaceFilter::CreateSurface( int time, vtkImageData *vtkimage, mitk::Surface * surface, mitk::LabeledImageToSurfaceFilter::LabelType label )
 {
   vtkImageChangeInformation *indexCoordinatesImageFilter = vtkImageChangeInformation::New();
   indexCoordinatesImageFilter->SetInput(vtkimage);
   indexCoordinatesImageFilter->SetOutputOrigin(0.0,0.0,0.0);
 
     vtkImageThreshold* threshold = vtkImageThreshold::New();
     threshold->SetInput( indexCoordinatesImageFilter->GetOutput() );
     //indexCoordinatesImageFilter->Delete();
     threshold->SetInValue( 100 );
     threshold->SetOutValue( 0 );
     threshold->ThresholdBetween( label, label );
     threshold->SetOutputScalarTypeToUnsignedChar();
     threshold->ReleaseDataFlagOn();
 
     vtkImageGaussianSmooth *gaussian = vtkImageGaussianSmooth::New();
     gaussian->SetInput( threshold->GetOutput() );
     //threshold->Delete();
     gaussian->SetDimensionality( 3  );
     gaussian->SetRadiusFactor( 0.49 );
     gaussian->SetStandardDeviation( GetGaussianStandardDeviation() );
     gaussian->ReleaseDataFlagOn();
     gaussian->UpdateInformation();
     gaussian->Update();
 
   //MarchingCube -->create Surface
   vtkMarchingCubes *skinExtractor = vtkMarchingCubes::New();
   skinExtractor->ReleaseDataFlagOn();
   skinExtractor->SetInput(gaussian->GetOutput());//RC++
   indexCoordinatesImageFilter->Delete();
   skinExtractor->SetValue(0, 50);
 
   vtkPolyData *polydata;
   polydata = skinExtractor->GetOutput();
   polydata->Register(NULL);//RC++
   skinExtractor->Delete();
 
   if (m_Smooth)
   {
     vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New();
     //read poly1 (poly1 can be the original polygon, or the decimated polygon)
     smoother->SetInput(polydata);//RC++
     smoother->SetNumberOfIterations( m_SmoothIteration );
     smoother->SetRelaxationFactor( m_SmoothRelaxation );
     smoother->SetFeatureAngle( 60 );
     smoother->FeatureEdgeSmoothingOff();
     smoother->BoundarySmoothingOff();
     smoother->SetConvergence( 0 );
 
     polydata->Delete();//RC--
     polydata = smoother->GetOutput();
     polydata->Register(NULL);//RC++
     smoother->Delete();
   }
 
   //decimate = to reduce number of polygons
   if(m_Decimate==DecimatePro)
   {
     vtkDecimatePro *decimate = vtkDecimatePro::New();
     decimate->SplittingOff();
     decimate->SetErrorIsAbsolute(5);
     decimate->SetFeatureAngle(30);
     decimate->PreserveTopologyOn();
     decimate->BoundaryVertexDeletionOff();
     decimate->SetDegree(10); //std-value is 25!
 
     decimate->SetInput(polydata);//RC++
     decimate->SetTargetReduction(m_TargetReduction);
     decimate->SetMaximumError(0.002);
 
     polydata->Delete();//RC--
     polydata = decimate->GetOutput();
     polydata->Register(NULL);//RC++
     decimate->Delete();
   }
 
   polydata->Update();
 
   polydata->SetSource(NULL);
 
   if(polydata->GetNumberOfPoints() > 0)
   {
     mitk::Vector3D spacing = GetInput()->GetGeometry(time)->GetSpacing();
 
     vtkPoints * points = polydata->GetPoints();
     vtkMatrix4x4 *vtkmatrix = vtkMatrix4x4::New();
     GetInput()->GetGeometry(time)->GetVtkTransform()->GetMatrix(vtkmatrix);
     double (*matrix)[4] = vtkmatrix->Element;
 
     unsigned int i,j;
     for(i=0;i<3;++i)
       for(j=0;j<3;++j)
         matrix[i][j]/=spacing[j];
 
     unsigned int n = points->GetNumberOfPoints();
     vtkFloatingPointType point[3];
 
     for (i = 0; i < n; i++)
     {
       points->GetPoint(i, point);
       mitkVtkLinearTransformPoint(matrix,point,point);
       points->SetPoint(i, point);
     }
     vtkmatrix->Delete();
   }
 
   surface->SetVtkPolyData(polydata, time);
   polydata->UnRegister(NULL);
 
   gaussian->Delete();
   threshold->Delete();
 }
 
 template < typename TPixel, unsigned int VImageDimension >
     void GetAvailableLabelsInternal( itk::Image<TPixel, VImageDimension>* image, mitk::LabeledImageToSurfaceFilter::LabelMapType& availableLabels )
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::ImageRegionIterator< ImageType > ImageRegionIteratorType;
   availableLabels.clear();
   ImageRegionIteratorType it( image, image->GetLargestPossibleRegion() );
   it.GoToBegin();
   mitk::LabeledImageToSurfaceFilter::LabelMapType::iterator labelIt;
   while( ! it.IsAtEnd() )
   {
     labelIt = availableLabels.find( ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) );
     if ( labelIt == availableLabels.end() )
     {
       availableLabels[ ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) ] = 1;
     }
     else
     {
       labelIt->second += 1;
     }
 
     ++it;
   }
 }
 
 #define InstantiateAccessFunction_GetAvailableLabelsInternal(pixelType, dim) \
 template void GetAvailableLabelsInternal(itk::Image<pixelType, dim>*, mitk::LabeledImageToSurfaceFilter::LabelMapType&);
 
 InstantiateAccessFunctionForFixedDimension(GetAvailableLabelsInternal, 3);
 
 
 mitk::LabeledImageToSurfaceFilter::LabelMapType mitk::LabeledImageToSurfaceFilter::GetAvailableLabels()
 {
   mitk::Image::Pointer image =  ( mitk::Image* )GetInput();
   LabelMapType availableLabels;
   AccessFixedDimensionByItk_1( image, GetAvailableLabelsInternal, 3, availableLabels );
   return availableLabels;
 }
 
 
 void mitk::LabeledImageToSurfaceFilter::CreateSurface(int, vtkImageData*, mitk::Surface*, const ScalarType)
 {
   itkWarningMacro( "This function should never be called!" );
   assert(false);
 }
 
 mitk::LabeledImageToSurfaceFilter::LabelType mitk::LabeledImageToSurfaceFilter::GetLabelForNthOutput( const unsigned int& idx )
 {
   IdxToLabelMapType::iterator it = m_IdxToLabels.find( idx );
   if ( it != m_IdxToLabels.end() )
   {
     return it->second;
   }
   else
   {
     itkWarningMacro( "Unknown index encountered: " << idx << ". There are " << this->GetNumberOfOutputs() << " outputs available." );
     return itk::NumericTraits<LabelType>::max();
   }
 }
 
 mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForNthOutput( const unsigned int& i )
 {
   return GetVolumeForLabel( GetLabelForNthOutput( i ) );
 }
 
 mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForLabel( const mitk::LabeledImageToSurfaceFilter::LabelType& label )
 {
   // get the image spacing
   mitk::Image* image =  ( mitk::Image* )GetInput();
   const float* spacing = image->GetSlicedGeometry()->GetFloatSpacing();
 
   // get the number of voxels encountered for the given label,
   // calculate the volume and return it.
   LabelMapType::iterator it = m_AvailableLabels.find( label );
   if ( it != m_AvailableLabels.end() )
   {
     return static_cast<float>(it->second) * ( spacing[0] * spacing[1] * spacing[2] / 1000.0f );
   }
   else
   {
     itkWarningMacro( "Unknown label encountered: " << label );
     return 0.0;
   }
 }
 
 
diff --git a/Modules/MitkExt/Algorithms/mitkLabeledImageVolumeCalculator.cpp b/Modules/MitkExt/Algorithms/mitkLabeledImageVolumeCalculator.cpp
index fe7286649d..02364f84b1 100644
--- a/Modules/MitkExt/Algorithms/mitkLabeledImageVolumeCalculator.cpp
+++ b/Modules/MitkExt/Algorithms/mitkLabeledImageVolumeCalculator.cpp
@@ -1,149 +1,146 @@
 /*===================================================================
 
 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 "mitkLabeledImageVolumeCalculator.h"
 #include "mitkImageAccessByItk.h"
 
 #include <itkImageRegionConstIteratorWithIndex.h>
 
 namespace mitk
 {
 
 LabeledImageVolumeCalculator::LabeledImageVolumeCalculator()
 {
   m_InputTimeSelector = ImageTimeSelector::New();
 
   m_DummyPoint.Fill( 0.0 );
 }
 
 
 LabeledImageVolumeCalculator::~LabeledImageVolumeCalculator()
 {
 }
 
 
 double LabeledImageVolumeCalculator::GetVolume( unsigned int label ) const
 {
   if ( label < m_VolumeVector.size() )
     return m_VolumeVector[label];
   else
     return 0.0;
 }
 
 const Point3D &LabeledImageVolumeCalculator::GetCentroid( unsigned int label ) const
 {
   if ( label < m_CentroidVector.size() )
     return m_CentroidVector[label];
   else
     return m_DummyPoint;
 }
 
 
 const LabeledImageVolumeCalculator::VolumeVector &
 LabeledImageVolumeCalculator::GetVolumes() const
 {
   return m_VolumeVector;
 }
 
 
 const LabeledImageVolumeCalculator::PointVector &
 LabeledImageVolumeCalculator::GetCentroids() const
 {
   return m_CentroidVector;
 }
 
 
 void LabeledImageVolumeCalculator::Calculate()
 {
   if ( m_Image.IsNull() )
   {
     itkExceptionMacro( << "Image not set!" );
     return;
   }
 
   m_InputTimeSelector->SetInput( m_Image );
 
-  //const TimeSlicedGeometry *timeSlicedGeometry = m_Image->GetTimeSlicedGeometry();
-  //for( unsigned int t = 0; t < timeSlicedGeometry->GetTimeSteps(); ++t )
-  //{
   m_InputTimeSelector->SetTimeNr( 0 );
   m_InputTimeSelector->UpdateLargestPossibleRegion();
 
   AccessByItk_2(
     m_InputTimeSelector->GetOutput(),
     _InternalCalculateVolumes,
     this,
     m_Image->GetGeometry( 0 ) );
   //}
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void LabeledImageVolumeCalculator::_InternalCalculateVolumes(
   itk::Image< TPixel, VImageDimension > *image,
   LabeledImageVolumeCalculator* /*volumeCalculator*/,
   Geometry3D *geometry )
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
   typedef typename ImageType::IndexType IndexType;
   typedef itk::ImageRegionConstIteratorWithIndex< ImageType > IteratorType;
 
   // Reset volume and centroid vectors
   m_VolumeVector.clear();
   m_CentroidVector.clear();
 
   // Iterate over image and determine number of voxels and centroid
   // per label
   IteratorType it( image, image->GetBufferedRegion() );
   for ( it.GoToBegin(); !it.IsAtEnd(); ++it )
   {
     const IndexType &index = it.GetIndex();
     unsigned int pixel = static_cast<unsigned int>( it.Get() );
 
     if ( m_VolumeVector.size() <= pixel )
     {
       m_VolumeVector.resize( pixel + 1 );
       m_CentroidVector.resize( pixel + 1 );
     }
 
     m_VolumeVector[pixel] += 1.0;
 
     m_CentroidVector[pixel][0] += index[0];
     m_CentroidVector[pixel][1] += index[1];
     m_CentroidVector[pixel][2] += index[2];
   }
 
   // Calculate voxel volume from spacing
   const Vector3D &spacing = geometry->GetSpacing();
   double voxelVolume = spacing[0] * spacing[1] * spacing[2];
 
   // Calculate centroid (in world coordinates) and volumes for all labels
   for ( unsigned int i = 0; i < m_VolumeVector.size(); ++i )
   {
     if ( m_VolumeVector[i] > 0.0 )
     {
       m_CentroidVector[i][0] /= m_VolumeVector[i];
       m_CentroidVector[i][1] /= m_VolumeVector[i];
       m_CentroidVector[i][2] /= m_VolumeVector[i];
       geometry->IndexToWorld( m_CentroidVector[i], m_CentroidVector[i] );
 
       m_VolumeVector[i] *= voxelVolume;
     }
   }
 }
 
 }
diff --git a/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
index 39e803abc2..fc1d7c0e88 100644
--- a/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
@@ -1,185 +1,185 @@
 /*===================================================================
 
 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 "mitkMaskImageFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkTimeHelper.h"
 #include "mitkProperties.h"
 
 #include "mitkImageToItk.h"
 #include "mitkImageAccessByItk.h"
 
 #include "itkImageRegionConstIterator.h"
 #include "itkImageRegionIteratorWithIndex.h"
 
 #include <limits>
 
 mitk::MaskImageFilter::MaskImageFilter() : m_Mask(NULL)
 {
   this->SetNumberOfIndexedInputs(2);
   this->SetNumberOfRequiredInputs(2);
   m_InputTimeSelector  = mitk::ImageTimeSelector::New();
   m_MaskTimeSelector   = mitk::ImageTimeSelector::New();
   m_OutputTimeSelector = mitk::ImageTimeSelector::New();
   m_OverrideOutsideValue = false;
   m_OutsideValue = 0;
 }
 
 mitk::MaskImageFilter::~MaskImageFilter()
 {
 
 }
 
 void mitk::MaskImageFilter::SetMask( const mitk::Image* mask )
 {
   // Process object is not const-correct so the const_cast is required here
   m_Mask = const_cast< mitk::Image * >( mask );
   this->ProcessObject::SetNthInput(1, m_Mask );
 }
 
 const mitk::Image* mitk::MaskImageFilter::GetMask() const
 {
   return m_Mask;
 }
 
 void mitk::MaskImageFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::Image* output = this->GetOutput();
   mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
   mitk::Image* mask  = m_Mask ;
-  if((output->IsInitialized()==false) || (mask == NULL) || (mask->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
+  if((output->IsInitialized()==false) || (mask == NULL) || (mask->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
     return;
 
   input->SetRequestedRegionToLargestPossibleRegion();
   mask->SetRequestedRegionToLargestPossibleRegion();
 
   GenerateTimeInInputRegion(output, input);
   GenerateTimeInInputRegion(output, mask);
 }
 
 void mitk::MaskImageFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
-  output->Initialize(input->GetPixelType(), *input->GetTimeSlicedGeometry());
+  output->Initialize(input->GetPixelType(), *input->GetTimeGeometry());
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void mitk::MaskImageFilter::InternalComputeMask(itk::Image<TPixel, VImageDimension>* inputItkImage)
 {
   typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
   typedef itk::Image<unsigned char, VImageDimension> ItkMaskImageType;
   typedef itk::Image<TPixel, VImageDimension> ItkOutputImageType;
 
   typedef itk::ImageRegionConstIterator< ItkInputImageType > ItkInputImageIteratorType;
   typedef itk::ImageRegionConstIterator< ItkMaskImageType > ItkMaskImageIteratorType;
   typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
 
   typename mitk::ImageToItk<ItkMaskImageType>::Pointer maskimagetoitk = mitk::ImageToItk<ItkMaskImageType>::New();
   maskimagetoitk->SetInput(m_MaskTimeSelector->GetOutput());
   maskimagetoitk->Update();
   typename ItkMaskImageType::Pointer maskItkImage = maskimagetoitk->GetOutput();
 
   typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
   outputimagetoitk->SetInput(m_OutputTimeSelector->GetOutput());
   outputimagetoitk->Update();
   typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
 
   // create the iterators
   typename ItkInputImageType::RegionType inputRegionOfInterest = inputItkImage->GetLargestPossibleRegion();
   ItkInputImageIteratorType  inputIt( inputItkImage, inputRegionOfInterest );
   ItkMaskImageIteratorType  maskIt ( maskItkImage, inputRegionOfInterest );
   ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
 
   //typename ItkOutputImageType::PixelType outsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
   if ( !m_OverrideOutsideValue )
     m_OutsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
 
   m_MinValue = std::numeric_limits<mitk::ScalarType>::max();
   m_MaxValue = std::numeric_limits<mitk::ScalarType>::min();
 
   for ( inputIt.GoToBegin(), maskIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd() && !maskIt.IsAtEnd(); ++inputIt, ++maskIt, ++outputIt)
   {
     if ( maskIt.Get() > itk::NumericTraits<typename ItkMaskImageType::PixelType>::Zero )
     {
       outputIt.Set(inputIt.Get());
       m_MinValue = vnl_math_min((float)inputIt.Get(), (float)m_MinValue);
       m_MaxValue = vnl_math_max((float)inputIt.Get(), (float)m_MaxValue);
     }
     else
     {
       outputIt.Set(m_OutsideValue);
     }
   }
 }
 
 void mitk::MaskImageFilter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer mask  = m_Mask;
   mitk::Image::Pointer output = this->GetOutput();
 
-  if((output->IsInitialized()==false) || (mask.IsNull()) || (mask->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
+  if((output->IsInitialized()==false) || (mask.IsNull()) || (mask->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
     return;
 
   m_InputTimeSelector->SetInput(input);
   m_MaskTimeSelector->SetInput(mask);
   m_OutputTimeSelector->SetInput(this->GetOutput());
 
   mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
-  const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *maskTimeGeometry = mask->GetTimeSlicedGeometry();
+  const mitk::TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
+  const mitk::TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
+  const mitk::TimeGeometry *maskTimeGeometry = mask->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->TimeStepToMS( t );
+    timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
 
-    timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
+    timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
 
     m_InputTimeSelector->SetTimeNr(timestep);
     m_InputTimeSelector->UpdateLargestPossibleRegion();
     m_OutputTimeSelector->SetTimeNr(t);
     m_OutputTimeSelector->UpdateLargestPossibleRegion();
 
-    timestep = maskTimeGeometry->MSToTimeStep( timeInMS );
+    timestep = maskTimeGeometry->TimePointToTimeStep( timeInMS );
     m_MaskTimeSelector->SetTimeNr(timestep);
     m_MaskTimeSelector->UpdateLargestPossibleRegion();
 
     AccessByItk(m_InputTimeSelector->GetOutput(),InternalComputeMask);
   }
 
   m_TimeOfHeaderInitialization.Modified();
 }
diff --git a/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp b/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp
index e04fd0d26b..ad2239fabf 100644
--- a/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp
@@ -1,202 +1,205 @@
 /*===================================================================
 
 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 "mitkPlaneFit.h"
 
 #include "mitkPlaneGeometry.h"
 #include "mitkGeometryData.h"
+#include <mitkProportionalTimeGeometry.h>
 
 #include <vnl/algo/vnl_svd.h>
 #include <vcl_iostream.h>
 
 
 mitk::PlaneFit::PlaneFit()
 : m_PointSet( NULL )
 {
-  m_TimeSlicedGeometry = mitk::TimeSlicedGeometry::New();
+  m_TimeGeometry = mitk::ProportionalTimeGeometry::New();
 }
 
 mitk::PlaneFit::~PlaneFit()
 {
 }
 
 
 void mitk::PlaneFit::GenerateOutputInformation()
 {
   mitk::PointSet::ConstPointer input  = this->GetInput();
   mitk::GeometryData::Pointer output  = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   if (input.IsNull()) return;
 
   if ( m_PointSet == NULL )
   {
     return;
   }
 
   bool update = false;
-  if ( output->GetGeometry() == NULL || output->GetTimeSlicedGeometry() == NULL )
+  if ( output->GetGeometry() == NULL || output->GetTimeGeometry() == NULL )
     update = true;
-  if ( ( ! update ) && ( output->GetTimeSlicedGeometry()->GetTimeSteps() != input->GetTimeSlicedGeometry()->GetTimeSteps() ) )
+  if ( ( ! update ) && ( output->GetTimeGeometry()->GetNumberOfTimeSteps() != input->GetTimeGeometry()->GetNumberOfTimeSteps() ) )
     update = true;
   if ( update )
   {
     mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
 
-    m_TimeSlicedGeometry->InitializeEvenlyTimed(
-      planeGeometry, m_PointSet->GetPointSetSeriesSize() );
+    ProportionalTimeGeometry::Pointer timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(m_TimeGeometry.GetPointer());
+    timeGeometry->Initialize(planeGeometry, m_PointSet->GetPointSetSeriesSize());
+    //m_TimeGeometry->InitializeEvenlyTimed(
+    //  planeGeometry, m_PointSet->GetPointSetSeriesSize() );
 
-    unsigned int t;
-    for ( t = 0;
-          (t < m_PointSet->GetPointSetSeriesSize())
-          && (t < m_Planes.size());
-          ++t )
+    TimeStepType timeStep;
+    for ( timeStep = 0;
+          (timeStep < m_PointSet->GetPointSetSeriesSize())
+          && (timeStep < m_Planes.size());
+          ++timeStep )
     {
-      m_TimeSlicedGeometry->SetGeometry3D( m_Planes[t], (int) t );
+      timeGeometry->SetTimeStepGeometry( m_Planes[timeStep], timeStep );
     }
 
-    output->SetGeometry( m_TimeSlicedGeometry );
+    output->SetTimeGeometry( m_TimeGeometry );
   }
 }
 
 void mitk::PlaneFit::GenerateData()
 {
   unsigned int t;
   for ( t = 0; t < m_PointSet->GetPointSetSeriesSize(); ++t )
   {
     // check number of data points - less then 3points isn't enough
     if ( m_PointSet->GetSize( t ) >= 3 )
     {
       this->CalculateCentroid( t );
 
       this->ProcessPointSet( t );
 
       this->InitializePlane( t );
     }
   }
 }
 
 void mitk::PlaneFit::SetInput( const mitk::PointSet* pointSet )
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0,
     const_cast< mitk::PointSet * >( pointSet ) );
 
   m_PointSet = pointSet;
   unsigned int pointSetSize = pointSet->GetPointSetSeriesSize();
 
   m_Planes.resize( pointSetSize );
   m_Centroids.resize( pointSetSize );
   m_PlaneVectors.resize( pointSetSize );
 
   unsigned int t;
   for ( t = 0; t < pointSetSize; ++t )
   {
     m_Planes[t] = mitk::PlaneGeometry::New();
   }
 }
 
 const mitk::PointSet* mitk::PlaneFit::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::PointSet * > (this->ProcessObject::GetInput(0) );
 }
 
 
 void mitk::PlaneFit::CalculateCentroid( int t )
 {
   if ( m_PointSet == NULL ) return;
 
   int ps_total = m_PointSet->GetSize( t );
 
   m_Centroids[t][0] = m_Centroids[t][1] = m_Centroids[t][2] = 0.0;
 
   for (int i=0; i<ps_total; i++)
   {
     mitk::Point3D p3d = m_PointSet->GetPoint(i,t);
     m_Centroids[t][0] += p3d[0];
     m_Centroids[t][1] += p3d[1];
     m_Centroids[t][2] += p3d[2];
   }
 
   // calculation of centroid
   m_Centroids[t][0] /= ps_total;
   m_Centroids[t][1] /= ps_total;
   m_Centroids[t][2] /= ps_total;
 }
 
 
 void mitk::PlaneFit::ProcessPointSet( int t )
 {
   if (m_PointSet == NULL ) return;
 
   // int matrix with POINTS x (X,Y,Z)
   vnl_matrix<mitk::ScalarType> dataM( m_PointSet->GetSize( t ), 3);
 
   int ps_total = m_PointSet->GetSize( t );
   for (int i=0; i<ps_total; i++)
   {
     mitk::Point3D p3d = m_PointSet->GetPoint(i,t);
     dataM[i][0] = p3d[0] - m_Centroids[t][0];
     dataM[i][1] = p3d[1] - m_Centroids[t][1];
     dataM[i][2] = p3d[2] - m_Centroids[t][2];
   }
   // process the SVD (singular value decomposition) from ITK
   // the vector will be orderd   descending
   vnl_svd<mitk::ScalarType> svd(dataM, 0.0);
 
   // calculate the SVD of A
   vnl_vector<mitk::ScalarType> v = svd.nullvector();
 
 
   // Avoid erratic normal sign switching when the plane changes minimally
   // by negating the vector for negative x values.
   if ( v[0] < 0 )
   {
     v = -v;
   }
 
   m_PlaneVectors[t][0] = v[0];
   m_PlaneVectors[t][1] = v[1];
   m_PlaneVectors[t][2] = v[2];
 
 }
 
 mitk::PlaneGeometry::Pointer mitk::PlaneFit::GetPlaneGeometry( int t )
 {
   return m_Planes[t];
 }
 
 const mitk::Vector3D &mitk::PlaneFit::GetPlaneNormal( int t ) const
 {
   return m_PlaneVectors[t];
 }
 
 const mitk::Point3D &mitk::PlaneFit::GetCentroid( int t ) const
 {
   return m_Centroids[t];
 }
 
 void mitk::PlaneFit::InitializePlane( int t )
 {
   m_Planes[t]->InitializePlane( m_Centroids[t], m_PlaneVectors[t] );
 }
 
diff --git a/Modules/MitkExt/Algorithms/mitkPlaneFit.h b/Modules/MitkExt/Algorithms/mitkPlaneFit.h
index 976dc4daec..74fd2ec6ad 100644
--- a/Modules/MitkExt/Algorithms/mitkPlaneFit.h
+++ b/Modules/MitkExt/Algorithms/mitkPlaneFit.h
@@ -1,147 +1,147 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #if !defined(MITK_PLANEFIT_H__INCLUDED_)
 #define MITK_PLANEFIT_H__INCLUDED_
 
 #include "mitkPointSet.h"
 #include "MitkExtExports.h"
-#include "mitkTimeSlicedGeometry.h"
+#include "mitkTimeGeometry.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkGeometryDataSource.h"
 
 namespace mitk {
 
   //!
   //  kind regards to dr. math!
   // function [x0, a, d, normd] = lsplane(X)
   // ---------------------------------------------------------------------
   // LSPLANE.M   Least-squares plane (orthogonal distance
   //             regression).
   //
   // Version 1.0
   // Last amended   I M Smith 27 May 2002.
   // Created        I M Smith 08 Mar 2002
   // ---------------------------------------------------------------------
   // Input
   // X        Array [x y z] where x = vector of x-coordinates,
   //          y = vector of y-coordinates and z = vector of
   //          z-coordinates.
   //          Dimension: m x 3.
   //
   // Output
   // x0       Centroid of the data = point on the best-fit plane.
   //          Dimension: 3 x 1.
   //
   // a        Direction cosines of the normal to the best-fit
   //          plane.
   //          Dimension: 3 x 1.
   //
   // <Optional...
   // d        Residuals.
   //          Dimension: m x 1.
   //
   // normd    Norm of residual errors.
   //          Dimension: 1 x 1.
   // ...>
   //
   // [x0, a <, d, normd >] = lsplane(X)
   // ---------------------------------------------------------------------
 
   class MitkExt_EXPORT PlaneFit : public GeometryDataSource
   {
     public:
 
       mitkClassMacro( PlaneFit, GeometryDataSource);
       itkNewMacro(Self);
 
       typedef mitk::PointSet::PointDataType PointDataType;
       typedef mitk::PointSet::PointDataIterator PointDataIterator;
 
       virtual void GenerateOutputInformation();
 
       virtual void GenerateData();
 
       /*!Getter for point set.
        *
        */
       const mitk::PointSet *GetInput();
 
       /*! filter initialisation.
        *
        */
       virtual void SetInput( const mitk::PointSet *ps );
 
       /*! returns the center of gravity of the point set.
        *
        */
       virtual const mitk::Point3D &GetCentroid( int t = 0 ) const;
 
       /*! returns the plane geometry which represents the point set.
        *
        */
       virtual mitk::PlaneGeometry::Pointer GetPlaneGeometry( int t = 0 );
 
       /*! returns the normal of the plane which represents the point set.
        *
        */
       virtual const mitk::Vector3D &GetPlaneNormal( int t = 0 ) const;
 
     protected:
       PlaneFit();
       virtual ~PlaneFit();
 
       /*! Calculates the centroid of the point set.
        * the center of gravity is calculated  through the mean value of the whole point set
        */
       void CalculateCentroid( int t = 0 );
 
       /*! working with an SVD algorithm form matrix dataM.
        * ITK suplies the vnl_svd to solve an plan fit eigentvector problem
        * points are processed in the SVD matrix. The normal vector is the
        * singular vector of dataM corresponding to its smalest singular value.
        * The mehtod uses VNL library from ITK and at least the mehtod nullvector()
        * to extract the normalvector.
        */
       void ProcessPointSet( int t = 0 );
 
       /*! Initialize Plane and configuration.
        *
        */
       void InitializePlane( int t = 0 );
 
 
     private:
 
       /*!keeps a copy of the pointset.*/
       const mitk::PointSet* m_PointSet;
 
       /* output object - a time sliced geometry.*/
-      mitk::TimeSlicedGeometry::Pointer m_TimeSlicedGeometry;
+      mitk::TimeGeometry::Pointer m_TimeGeometry;
 
       std::vector< mitk::PlaneGeometry::Pointer > m_Planes;
 
       /*! the calculatet center point of all points in the point set.*/
       std::vector< mitk::Point3D > m_Centroids;
 
       /* the normal vector to descrie a plane gemoetry.*/
       std::vector< mitk::Vector3D > m_PlaneVectors;
   };
 }//namespace mitk
 #endif //MITK_PLANFIT_INCLUDE_
 
 
diff --git a/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.h b/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.h
index 2ea32b719a..cc4f3261ea 100644
--- a/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.h
+++ b/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.h
@@ -1,144 +1,144 @@
 /*===================================================================
 
 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).
 
 
 
 //## @ingroup Process
 class MitkExt_EXPORT PlanesPerpendicularToLinesFilter : public GeometryDataSource
 {
 public:
   mitkClassMacro(PlanesPerpendicularToLinesFilter, GeometryDataSource);
   itkNewMacro(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::Geometry3D* 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::Geometry3D::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::AffineGeometryFrame3D::BoundsArrayType bounds;
+  mitk::Geometry3D::BoundsArrayType bounds;
   Point3D origin;
 };
 
 } // namespace mitk
 
 #endif /* MITKPLANESPERPENDICULARTOLINES_H_HEADER_INCLUDED_C10B22CD */
diff --git a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
index ab13046819..ed60e81010 100644
--- a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
@@ -1,181 +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 "mitkTimeSlicedGeometry.h"
 #include "mitkDataNode.h"
 #include "mitkGeometryData.h"
 #include "mitkGeometry2DData.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() );
   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() );
 
   if ( input.IsNull() )
     itkGenericExceptionMacro ( "Input point set is NULL!" );
 
-  if ( input->GetTimeSlicedGeometry()->GetTimeSteps() != 1 )
+  if ( input->GetTimeGeometry()->GetNumberOfTimeSteps() != 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->GetTimeSlicedGeometry() == NULL )
+  if ( output->GetGeometry() == NULL || output->GetGeometry2D() == NULL || output->GetTimeGeometry() == NULL )
     update = true;
-  if ( ( ! update ) && ( output->GetTimeSlicedGeometry()->GetTimeSteps() != input->GetTimeSlicedGeometry()->GetTimeSteps() ) )
+  if ( ( ! update ) && ( output->GetTimeGeometry()->GetNumberOfTimeSteps() != input->GetTimeGeometry()->GetNumberOfTimeSteps() ) )
     update = true;
   if ( update )
   {
     mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
     output->SetGeometry(curvedGeometry);
-
-    /*
-    mitk::TimeSlicedGeometry::Pointer timeGeometry = mitk::TimeSlicedGeometry::New();
-    mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
-
-    timeGeometry->InitializeEvenlyTimed ( curvedGeometry, input->GetPointSetSeriesSize() );
-
-    for ( unsigned int t = 1; t < input->GetPointSetSeriesSize(); ++t )
-    {
-      mitk::ThinPlateSplineCurvedGeometry::Pointer tmpCurvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
-      timeGeometry->SetGeometry3D ( tmpCurvedGeometry.GetPointer(), t );
-    }
-    output->SetGeometry ( timeGeometry );
-    output->SetGeometry2D ( curvedGeometry ); // @FIXME SetGeometry2D of mitk::Geometry2DData reinitializes the TimeSlicedGeometry to 1 time step
-    */
   }
 }
 
 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->GetTimeSlicedGeometry() == NULL )
+  if ( output->GetTimeGeometry() == NULL )
     itkGenericExceptionMacro ( "Output time sliced geometry is NULL!" );
-  if ( output->GetTimeSlicedGeometry()->GetGeometry3D ( 0 ) == NULL )
+  if ( output->GetTimeGeometry()->GetGeometryForTimeStep ( 0 ).IsNull() )
     itkGenericExceptionMacro ( "Output geometry3d is NULL!" );
-  mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = dynamic_cast<mitk::ThinPlateSplineCurvedGeometry*> ( output->GetTimeSlicedGeometry()->GetGeometry3D ( 0 ) );
+  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::Geometry3D* 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/MitkExt/Algorithms/mitkProbeFilter.cpp b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
index b6f7ea710a..766bcb0654 100644
--- a/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
@@ -1,215 +1,214 @@
 /*===================================================================
 
 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 "mitkProbeFilter.h"
 #include "mitkSurface.h"
 #include "mitkImage.h"
-#include "mitkTimeSlicedGeometry.h"
 
 #include <vtkPolyDataSource.h>
 #include <vtkProbeFilter.h>
 #include <itkImageRegion.h>
 #include <vtkDataSet.h>
 #include <vtkPolyData.h>
 #include <vtkImageData.h>
 
 mitk::ProbeFilter::ProbeFilter()
 {
 
 }
 
 mitk::ProbeFilter::~ProbeFilter()
 {
 
 }
 
 const mitk::Surface *mitk::ProbeFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
   return static_cast< const mitk::Surface * >(this->ProcessObject::GetInput(0) );
 }
 
 const mitk::Image *mitk::ProbeFilter::GetSource(void)
 {
   return static_cast< const mitk::Image * >(this->ProcessObject::GetInput(1));
 }
 
 void mitk::ProbeFilter::SetInput(const mitk::Surface *input)
 {
   this->ProcessObject::SetNthInput( 0, const_cast< mitk::Surface * >( input ) );
 }
 
 void mitk::ProbeFilter::SetSource(const mitk::Image *source)
 {
   this->ProcessObject::SetNthInput( 1, const_cast< mitk::Image * >( source ) );
 }
 
 void mitk::ProbeFilter::GenerateOutputInformation()
 {
   mitk::Surface::ConstPointer input  = this->GetInput();
   mitk::Image::ConstPointer source = this->GetSource();
   mitk::Surface::Pointer output = this->GetOutput();
 
   if(input.IsNull()) return;
   if(source.IsNull()) return;
 
   if(input->GetGeometry()==NULL) return;
   if(source->GetGeometry()==NULL) return;
 
-  if( (input->GetTimeSlicedGeometry()->GetTimeSteps()==1) && (source->GetTimeSlicedGeometry()->GetTimeSteps()>1) )
+  if( (input->GetTimeGeometry()->GetNumberOfTimeSteps()==1) && (source->GetTimeGeometry()->GetNumberOfTimeSteps()>1) )
   {
     Geometry3D::Pointer geometry3D = Geometry3D::New();
     geometry3D->Initialize();
-    geometry3D->SetBounds(source->GetTimeSlicedGeometry()->GetBounds());
-    geometry3D->SetTimeBounds(source->GetTimeSlicedGeometry()->GetGeometry3D(0)->GetTimeBounds());
+    geometry3D->SetBounds(source->GetTimeGeometry()->GetBoundsInWorld());
+    geometry3D->SetTimeBounds(source->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetTimeBounds());
 
-    TimeSlicedGeometry::Pointer outputTimeSlicedGeometry = TimeSlicedGeometry::New();
-    outputTimeSlicedGeometry->InitializeEvenlyTimed(geometry3D, source->GetTimeSlicedGeometry()->GetTimeSteps());
+    ProportionalTimeGeometry::Pointer outputTimeGeometry = ProportionalTimeGeometry::New();
+    outputTimeGeometry->Initialize(geometry3D, source->GetTimeGeometry()->GetNumberOfTimeSteps());
 
-    output->Expand(outputTimeSlicedGeometry->GetTimeSteps());
-    output->SetGeometry( outputTimeSlicedGeometry );
+    output->Expand(outputTimeGeometry->GetNumberOfTimeSteps());
+    output->SetTimeGeometry( outputTimeGeometry );
   }
   else
     output->SetGeometry( static_cast<Geometry3D*>(input->GetGeometry()->Clone().GetPointer()) );
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 }
 
 void mitk::ProbeFilter::GenerateData()
 {
   mitk::Surface *input  = const_cast< mitk::Surface * >(this->GetInput());
   mitk::Image *source = const_cast< mitk::Image * >(this->GetSource());
   mitk::Surface::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"Generating Data");
 
   if(output.IsNull())
   {
     itkDebugMacro(<<"Output is NULL.");
     return;
   }
 
   mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
-  const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
-  const mitk::TimeSlicedGeometry *sourceTimeGeometry = source->GetTimeSlicedGeometry();
-  ScalarType timeInMS;
+  const TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
+  const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
+  const TimeGeometry *sourceTimeGeometry = source->GetTimeGeometry();
+  TimePointType timeInMS;
   int timestep=0;
 
   int tstart, tmax;
 
   tstart=outputRegion.GetIndex(3);
   tmax=tstart+outputRegion.GetSize(3);
 
   int t;
   for(t=tstart;t<tmax;++t)
   {
-    timeInMS = outputTimeGeometry->TimeStepToMS( t );
+    timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
 
     vtkProbeFilter* probe = vtkProbeFilter::New();
 
-    timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
+    timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
     probe->SetInput( input->GetVtkPolyData(timestep) );
 
-    timestep = sourceTimeGeometry->MSToTimeStep( timeInMS );
+    timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
     probe->SetSource( source->GetVtkImageData(timestep) );
 
     output->SetVtkPolyData( probe->GetPolyDataOutput(), t );
 
     probe->Update();
     probe->Delete();
   }
 }
 
 void mitk::ProbeFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::Surface *input  = const_cast< mitk::Surface * >( this->GetInput() );
   mitk::Image *source = const_cast< mitk::Image * >( this->GetSource() );
 
   if(input==NULL) return;
   if(source==NULL) return;
 
   mitk::Surface::Pointer output = this->GetOutput();
   mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
-  const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
+  const TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
 
   mitk::Surface::RegionType inputSurfaceRegion = outputRegion;
   Image::RegionType sourceImageRegion = source->GetLargestPossibleRegion();
 
   if(outputRegion.GetSize(3)<1)
   {
     mitk::Surface::RegionType::SizeType surfacesize;
     surfacesize.Fill(0);
     inputSurfaceRegion.SetSize(surfacesize);
     input->SetRequestedRegion( &inputSurfaceRegion  );
     mitk::Image::RegionType::SizeType imagesize;
     imagesize.Fill(0);
     sourceImageRegion.SetSize(imagesize);
     source->SetRequestedRegion( &sourceImageRegion );
     return;
   }
 
   //create and set input requested region for the input surface
-  const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
+  const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
 
   ScalarType timeInMS;
   int timestep=0;
 
   // convert the start-index-time of output in start-index-time of input via millisecond-time
-  timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3));
-  timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
-  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( inputTimeGeometry->IsValidTime( timestep ) ) )
+  timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3));
+  timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
+  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( inputTimeGeometry->IsValidTimeStep( timestep ) ) )
     inputSurfaceRegion.SetIndex( 3, timestep );
   else
     inputSurfaceRegion.SetIndex( 3, 0 );
   // convert the end-index-time of output in end-index-time of input via millisecond-time
-  timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
-  timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
-  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTime( timestep ) ) )
+  timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
+  timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
+  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTimeStep( timestep ) ) )
     inputSurfaceRegion.SetSize( 3, timestep - inputSurfaceRegion.GetIndex(3) + 1 );
   else
     inputSurfaceRegion.SetSize( 3, 1 );
 
   input->SetRequestedRegion( &inputSurfaceRegion  );
 
   //create and set input requested region for the source image
-  const mitk::TimeSlicedGeometry *sourceTimeGeometry = source->GetTimeSlicedGeometry();
+  const TimeGeometry *sourceTimeGeometry = source->GetTimeGeometry();
 
   // convert the start-index-time of output in start-index-time of source via millisecond-time
-  timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3));
-  timestep = sourceTimeGeometry->MSToTimeStep( timeInMS );
-  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( sourceTimeGeometry->IsValidTime( timestep ) ) )
+  timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3));
+  timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
+  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( sourceTimeGeometry->IsValidTimeStep( timestep ) ) )
     sourceImageRegion.SetIndex( 3, timestep );
   else
     sourceImageRegion.SetIndex( 3, 0 );
   // convert the end-index-time of output in end-index-time of source via millisecond-time
-  timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
-  timestep = sourceTimeGeometry->MSToTimeStep( timeInMS );
-  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTime( timestep ) ) )
+  timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
+  timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
+  if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTimeStep( timestep ) ) )
     sourceImageRegion.SetSize( 3, timestep - sourceImageRegion.GetIndex(3) + 1 );
   else
     sourceImageRegion.SetSize( 3, 1 );
 
   sourceImageRegion.SetIndex( 4, 0 );
   sourceImageRegion.SetSize( 4, 1 );
 
   source->SetRequestedRegion( &sourceImageRegion );
 }
diff --git a/Modules/MitkExt/DataManagement/mitkBoundingObject.cpp b/Modules/MitkExt/DataManagement/mitkBoundingObject.cpp
index 5ddd75745b..c3755b4ac2 100644
--- a/Modules/MitkExt/DataManagement/mitkBoundingObject.cpp
+++ b/Modules/MitkExt/DataManagement/mitkBoundingObject.cpp
@@ -1,72 +1,72 @@
 /*===================================================================
 
 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 "mitkBoundingObject.h"
 #include "mitkBaseProcess.h"
 
 mitk::BoundingObject::BoundingObject()
   : Surface(), m_Positive(true)
 {
 //  Initialize(1);
 
   /* bounding box around the unscaled bounding object */
   ScalarType bounds[6]={-1,1,-1,1,-1,1};  //{xmin,x_max, ymin,y_max,zmin,z_max}
   GetGeometry()->SetBounds(bounds);
-  GetTimeSlicedGeometry()->UpdateInformation();
+  GetTimeGeometry()->Update();
 }
 
 mitk::BoundingObject::~BoundingObject()
 {
 }
 
 mitk::ScalarType mitk::BoundingObject::GetVolume()
 {
   return 0.0;
 }
 
 void mitk::BoundingObject::FitGeometry(mitk::Geometry3D* aGeometry3D)
 {
 
   // Adjusted this function to fix
   // BUG 6951 - Image Cropper - Bounding Box is strange
   // Still, the behavior of the BoundingObject is really strange.
   // One would think that writing "setGeometry(aGeometry3D)" here would do the job.
   // But apparently the boundingObject can only be handled correctly, when it's
   // indexBounds are from -1 to 1 in all axis (so it is only 2x2x2 Pixels big) and the spacing
   // specifies it's actual bounds. This behavior needs to be analyzed and maybe changed.
   // Check also BUG 11406
 
 
   GetGeometry()->SetIdentity();
   GetGeometry()->Compose(aGeometry3D->GetIndexToWorldTransform());
 
   // Since aGeometry (which should actually be const), is an imagegeometry and boundingObject is NOT an image,
   // we have to adjust the Origin by shifting it half pixel
   mitk::Point3D myOrigin = aGeometry3D->GetCenter();
   myOrigin[0] -= (aGeometry3D->GetSpacing()[0] / 2.0);
   myOrigin[1] -= (aGeometry3D->GetSpacing()[1] / 2.0);
   myOrigin[2] -= (aGeometry3D->GetSpacing()[2] / 2.0);
 
   GetGeometry()->SetOrigin(myOrigin);
 
   mitk::Vector3D size;
   for(unsigned int i=0; i < 3; ++i)
     size[i] = (aGeometry3D->GetExtentInMM(i)/2.0);
   GetGeometry()->SetSpacing( size );
-  GetTimeSlicedGeometry()->UpdateInformation();
+  GetTimeGeometry()->Update();
 
 }
diff --git a/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp b/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
index 83584911da..34db104cb4 100644
--- a/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
+++ b/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
@@ -1,212 +1,208 @@
 /*===================================================================
 
 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 "mitkBoundingObjectGroup.h"
 #include "mitkBaseProcess.h"
 #include <vtkLinearTransform.h>
+#include <mitkProportionalTimeGeometry.h>
 
 mitk::BoundingObjectGroup::BoundingObjectGroup()
 :m_BoundingObjects(0),
 m_Counter(0),
 m_CSGMode(Union)// m_CSGMode(Difference) //m_CSGMode(Intersection)
 {
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
-  GetGeometry(0)->SetIndexToWorldTransform(GetTimeSlicedGeometry()->GetIndexToWorldTransform());
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(1);
+  SetTimeGeometry(timeGeometry);
+
   SetVtkPolyData(NULL);
 }
 
 mitk::BoundingObjectGroup::~BoundingObjectGroup()
 {
 }
 
 void mitk::BoundingObjectGroup::UpdateOutputInformation()
 {
   if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
 
   // calculate global bounding box
   if(m_BoundingObjects.size()  < 1 ) // if there is no BoundingObject, the bounding box is zero
   {
     mitk::BoundingBox::BoundsArrayType boundsArray;
     boundsArray.Fill(0);
-    GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
+    ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+    timeGeometry->Initialize(1);
+    SetTimeGeometry(timeGeometry);
     GetGeometry()->SetBounds(boundsArray);
-    GetTimeSlicedGeometry()->UpdateInformation();
+    GetTimeGeometry()->Update();
     return;
   }
 
   // initialize container
   mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
 
   mitk::BoundingBox::PointIdentifier pointid=0;
   mitk::Point3D point;
 
-  mitk::AffineTransform3D* transform = GetTimeSlicedGeometry()->GetIndexToWorldTransform();
+  mitk::AffineTransform3D* transform = GetGeometry()->GetIndexToWorldTransform();
   mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
   transform->GetInverse(inverse);
 
   // calculate a bounding box that includes all BoundingObjects
   // \todo probably we should do this additionally for each time-step
   //while (boundingObjectsIterator != boundingObjectsIteratorEnd)
   for(unsigned int j = 0; j<m_BoundingObjects.size();j++)
   {
-    const Geometry3D* geometry = m_BoundingObjects.at(j)->GetUpdatedTimeSlicedGeometry();
+    const TimeGeometry* geometry = m_BoundingObjects.at(j)->GetUpdatedTimeGeometry();
     unsigned char i;
     for(i=0; i<8; ++i)
     {
-      point = inverse->TransformPoint(geometry->GetCornerPoint(i));
+      point = inverse->TransformPoint(geometry->GetCornerPointInWorld(i));
       if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < mitk::large)
         pointscontainer->InsertElement( pointid++, point);
       else
       {
         itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. BoundingObject: " << m_BoundingObjects.at(j) );
       }
     }
   }
 
   mitk::BoundingBox::Pointer boundingBox = mitk::BoundingBox::New();
   boundingBox->SetPoints(pointscontainer);
   boundingBox->ComputeBoundingBox();
 
-  /* BoundingBox is centered around the center of all sub bounding objects */
-  //Point3D center = boundingBox->GetCenter();
-
-  //Point3D minimum, maximum;
-  //minimum.Fill(0); maximum.Fill(0);
-  //minimum += boundingBox->GetMinimum() - center;
-  //maximum += boundingBox->GetMaximum() - center;
-
-  //boundingBox->SetMinimum(minimum);
-  //boundingBox->SetMaximum(maximum);
-
   Geometry3D* geometry3d = GetGeometry(0);
   geometry3d->SetIndexToWorldTransform(transform);
   geometry3d->SetBounds(boundingBox->GetBounds());
   /* the objects position is the center of all sub bounding objects */
   //geometry3d->SetOrigin(center);
 
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry3d, GetTimeSlicedGeometry()->GetTimeSteps());
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(geometry3d, GetTimeGeometry()->GetNumberOfTimeSteps());
+  SetTimeGeometry(timeGeometry);
 }
 
 void mitk::BoundingObjectGroup::AddBoundingObject(mitk::BoundingObject::Pointer boundingObject)
 {
   if (boundingObject->GetPositive())
     m_BoundingObjects.push_front(boundingObject);
   else
     m_BoundingObjects.push_back(boundingObject);
   ++m_Counter;
   UpdateOutputInformation();
 }
 
 void mitk::BoundingObjectGroup::RemoveBoundingObject(mitk::BoundingObject::Pointer boundingObject)
 {
   std::deque<mitk::BoundingObject::Pointer>::iterator it = m_BoundingObjects.begin();
   for (unsigned int i=0 ; i<m_BoundingObjects.size();i++)
   {
     if (m_BoundingObjects.at(i) == boundingObject)
       m_BoundingObjects.erase(it);
     ++it;
   }
   --m_Counter;
   UpdateOutputInformation();
 }
 
 bool mitk::BoundingObjectGroup::IsInside(const mitk::Point3D& p) const
 {
   bool inside = false; // initialize with true for intersection, with false for union
   bool posInside = false;
   bool negInside = false;
 
   for (unsigned int i = 0; i<m_BoundingObjects.size();i++)
   {
     switch(m_CSGMode)
     {
     case Intersection:
       inside = true;
       // calculate intersection: each point, that is inside each BoundingObject is considered inside the group
       inside = m_BoundingObjects.at(i)->IsInside(p) && inside;
       if (!inside) // shortcut, it is enough to find one object that does not contain the point
         i=m_BoundingObjects.size();
       break;
 
     case Union:
     case Difference:
       posInside = false;
       negInside = false;
       // calculate union: each point, that is inside least one BoundingObject is considered inside the group
       if (m_BoundingObjects.at(i)->GetPositive())
         posInside = m_BoundingObjects.at(i)->IsInside(p) || posInside;
       else
         negInside = m_BoundingObjects.at(i)->IsInside(p) || negInside;
 
       if (posInside && !negInside)
         inside = true;
       else
         inside = false;
       break;
 
     default:
       inside = false;
       // calculate union: each point, that is inside least one BoundingObject is considered inside the group
       inside = m_BoundingObjects.at(i)->IsInside(p) || inside;
       if (inside) // shortcut, it is enough to find one object that contains the point
         i=m_BoundingObjects.size();
       break;
     }
   }
   return inside;
 }
 
 unsigned int mitk::BoundingObjectGroup::GetCount() const
 {
   return m_Counter;
 }
 
 bool mitk::BoundingObjectGroup::VerifyRequestedRegion()
 {
   return m_Counter > 0;
 }
 
 mitk::Geometry3D *  mitk::BoundingObjectGroup::GetGeometry (int t) const
 {
   //if ( m_BoundingObjects == NULL )
   return Superclass::GetGeometry(t);
 
   //mitk::BoundingObjectGroup::BoundingObjectContainer::ConstIterator boI = m_BoundingObjects->Begin();
   //const mitk::BoundingObjectGroup::BoundingObjectContainer::ConstIterator boIEnd = m_BoundingObjects->End();
   //mitk::Geometry3D* currentGeometry = NULL;
 
   //while ( boI != boIEnd )
   //{
   //  currentGeometry = boI.Value()->GetGeometry( t );
   //  boI++;
   //}
 
   //return currentGeometry;
 }
 
 void mitk::BoundingObjectGroup::SetBoundingObjects(const std::deque<mitk::BoundingObject::Pointer> boundingObjects)
 {
   m_BoundingObjects = boundingObjects;
 }
 
 std::deque<mitk::BoundingObject::Pointer> mitk::BoundingObjectGroup::GetBoundingObjects()
 {
   return m_BoundingObjects;
 }
diff --git a/Modules/MitkExt/DataManagement/mitkCone.cpp b/Modules/MitkExt/DataManagement/mitkCone.cpp
index 68218175b7..e9831614ef 100644
--- a/Modules/MitkExt/DataManagement/mitkCone.cpp
+++ b/Modules/MitkExt/DataManagement/mitkCone.cpp
@@ -1,65 +1,65 @@
 /*===================================================================
 
 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 "mitkCone.h"
 #include "vtkLinearTransform.h"
 #include "mitkVector.h"
 #include "vtkConeSource.h"
 
 mitk::Cone::Cone()
 : BoundingObject()
 {
   // Set up Cone Surface. Radius 1.0, height 2.0, , centered around the origin
   vtkConeSource* cone = vtkConeSource::New();
   cone->SetRadius(1.0);
   cone->SetHeight(2.0);
   cone->SetDirection(0.0, -1.0, 0.0);
   cone->SetCenter(0.0, 0.0, 0.0);
   cone->SetResolution(20);
   cone->CappingOn();
   cone->Update();
   SetVtkPolyData(cone->GetOutput());
   cone->Delete();
 }
 
 mitk::Cone::~Cone()
 {
 }
 
 bool mitk::Cone::IsInside(const Point3D& worldPoint) const
 {
   // transform point from world to object coordinates
   ScalarType p[4];
   p[0] = worldPoint[0];
   p[1] = worldPoint[1];
   p[2] = worldPoint[2];
   p[3] = 1;
 
   GetGeometry()->GetVtkTransform()->GetInverse()->TransformPoint(p, p);
 
   p[1] += 1;  // translate point, so that it fits to the formula below, which describes a cone that has its cone vertex at the origin
   return (sqrt(p[0] * p[0] + p[2] * p[2]) <= p[1] * 0.5) && (p[1] <= 2);  // formula to calculate if a given point is inside a cone that has its cone vertex at the origin, is aligned on the second axis, has a radius of one an a height of two
 }
 
 mitk::ScalarType mitk::Cone::GetVolume()
 {
-  Geometry3D* geometry = GetTimeSlicedGeometry();
-  return   geometry->GetExtentInMM(0) * 0.5
-    * geometry->GetExtentInMM(2) * 0.5
+  TimeGeometry* geometry = GetTimeGeometry();
+  return   geometry->GetExtentInWorld(0) * 0.5
+    * geometry->GetExtentInWorld(2) * 0.5
     * vnl_math::pi / 3.0
-    * geometry->GetExtentInMM(1);
+    * geometry->GetExtentInWorld(1);
 }
diff --git a/Modules/MitkExt/DataManagement/mitkCuboid.cpp b/Modules/MitkExt/DataManagement/mitkCuboid.cpp
index 2e569b9dca..4ba86b8101 100644
--- a/Modules/MitkExt/DataManagement/mitkCuboid.cpp
+++ b/Modules/MitkExt/DataManagement/mitkCuboid.cpp
@@ -1,64 +1,64 @@
 /*===================================================================
 
 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 "mitkCuboid.h"
 #include "vtkLinearTransform.h"
 #include "mitkVector.h"
 #include "vtkCubeSource.h"
 
 #include <vtkSTLReader.h>
 
 mitk::Cuboid::Cuboid()
 : BoundingObject()
 {
   vtkCubeSource* cube = vtkCubeSource::New();
   cube->SetXLength(2.0);
   cube->SetYLength(2.0);
   cube->SetZLength(2.0);
   cube->Update();
   SetVtkPolyData(cube->GetOutput());
   cube->Delete();
 }
 
 mitk::Cuboid::~Cuboid()
 {
 
 }
 
 bool mitk::Cuboid::IsInside(const Point3D& worldPoint) const
 {
   // transform point from world to object coordinates
   ScalarType p[4];
   p[0] = worldPoint[0];
   p[1] = worldPoint[1];
   p[2] = worldPoint[2];
   p[3] = 1;
 
   GetGeometry()->GetVtkTransform()->GetInverse()->TransformPoint(p, p);
 
   return (p[0] >= -1) && (p[0] <= 1)
     && (p[1] >= -1) && (p[1] <= 1)
     && (p[2] >= -1) && (p[2] <= 1);
 }
 
 mitk::ScalarType mitk::Cuboid::GetVolume()
 {
-  Geometry3D* geometry = GetTimeSlicedGeometry();
-  return   geometry->GetExtentInMM(0)
-    * geometry->GetExtentInMM(1)
-    * geometry->GetExtentInMM(2);
+  TimeGeometry* geometry = GetTimeGeometry();
+  return   geometry->GetExtentInWorld(0)
+    * geometry->GetExtentInWorld(1)
+    * geometry->GetExtentInWorld(2);
 }
diff --git a/Modules/MitkExt/DataManagement/mitkCylinder.cpp b/Modules/MitkExt/DataManagement/mitkCylinder.cpp
index 4e32b17089..454869e2f2 100644
--- a/Modules/MitkExt/DataManagement/mitkCylinder.cpp
+++ b/Modules/MitkExt/DataManagement/mitkCylinder.cpp
@@ -1,68 +1,68 @@
 /*===================================================================
 
 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 "mitkCylinder.h"
 #include "vtkLinearTransform.h"
 #include "mitkVector.h"
 #include "vtkCylinderSource.h"
 
 
 mitk::Cylinder::Cylinder()
 : BoundingObject()
 {
   vtkCylinderSource* cylinder = vtkCylinderSource::New();
   cylinder->SetRadius(1.0);
   cylinder->SetHeight(2.0);
   cylinder->SetCenter(0.0, 0.0, 0.0);
   cylinder->SetResolution(100);
   cylinder->CappingOn();
   cylinder->Update();
   SetVtkPolyData(cylinder->GetOutput());
   cylinder->Delete();
 }
 
 
 mitk::Cylinder::~Cylinder()
 {
 }
 
 
 bool mitk::Cylinder::IsInside(const Point3D& worldPoint) const
 {
   // transform point from world to object coordinates
   ScalarType p[4];
   p[0] = worldPoint[0];
   p[1] = worldPoint[1];
   p[2] = worldPoint[2];
   p[3] = 1;
 
   GetGeometry()->GetVtkTransform()->GetInverse()->TransformPoint(p, p);
 
   mitk::ScalarType v =  pow(p[0], 2) + pow(p[2], 2);
   bool retval = (v <= 1) && (p[1] >= -1) && (p[1] <= 1);
   return retval;
 }
 
 
 mitk::ScalarType mitk::Cylinder::GetVolume()
 {
-  Geometry3D* geometry = GetTimeSlicedGeometry();
-  return   geometry->GetExtentInMM(0) * 0.5
-    * geometry->GetExtentInMM(2) * 0.5
+  TimeGeometry* geometry = GetTimeGeometry();
+  return   geometry->GetExtentInWorld(0) * 0.5
+    * geometry->GetExtentInWorld(2) * 0.5
     * vnl_math::pi
-    * geometry->GetExtentInMM(1);
+    * geometry->GetExtentInWorld(1);
 }
diff --git a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
index 86f1bb1866..bb0762ad40 100644
--- a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
+++ b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
@@ -1,248 +1,248 @@
 /*===================================================================
 
 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 "mitkUnstructuredGrid.h"
 
 #include <vtkUnstructuredGrid.h>
 
 void mitk::UnstructuredGrid::SetVtkUnstructuredGrid( vtkUnstructuredGrid* grid, unsigned int t )
 {
   this->Expand(t);
 
   if(m_GridSeries[ t ] != NULL)
   {
     m_GridSeries[ t ]->Delete();
   }
 
   m_GridSeries[ t ] = grid;
 
   // call m_VtkPolyData->Register(NULL) to tell the reference counting that we
   // want to keep a reference on the object
   if (m_GridSeries[t] != 0)
     m_GridSeries[t]->Register(grid);
 
   this->Modified();
   m_CalculateBoundingBox = true;
 }
 
 void mitk::UnstructuredGrid::Expand(unsigned int timeSteps)
 {
   // check if the vector is long enough to contain the new element
   // at the given position. If not, expand it with sufficient zero-filled elements.
   if(timeSteps > m_GridSeries.size())
   {
     Superclass::Expand(timeSteps);
     vtkUnstructuredGrid* pdnull = 0;
     m_GridSeries.resize( timeSteps, pdnull );
     m_CalculateBoundingBox = true;
   }
 }
 
 void mitk::UnstructuredGrid::ClearData()
 {
   for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin(); it != m_GridSeries.end(); ++it )
   {
     if ( ( *it ) != 0 )
       ( *it )->Delete();
   }
   m_GridSeries.clear();
 
   Superclass::ClearData();
 }
 
 void mitk::UnstructuredGrid::InitializeEmpty()
 {
   vtkUnstructuredGrid* pdnull = 0;
   m_GridSeries.resize( 1, pdnull );
-  Superclass::InitializeTimeSlicedGeometry(1);
+  Superclass::InitializeTimeGeometry(1);
 
   m_Initialized = true;
 }
 
 vtkUnstructuredGrid* mitk::UnstructuredGrid::GetVtkUnstructuredGrid(unsigned int t)
 {
   if ( t < m_GridSeries.size() )
   {
     vtkUnstructuredGrid* grid = m_GridSeries[ t ];
     if((grid == 0) && (GetSource().GetPointer() != 0))
     {
       RegionType requestedregion;
       requestedregion.SetIndex(3, t);
       requestedregion.SetSize(3, 1);
       SetRequestedRegion(&requestedregion);
       GetSource()->Update();
     }
     grid = m_GridSeries[ t ];
     return grid;
   }
   else
     return 0;
 }
 
 mitk::UnstructuredGrid::UnstructuredGrid() : m_CalculateBoundingBox( false )
 {
   this->InitializeEmpty();
 }
 
 mitk::UnstructuredGrid::UnstructuredGrid(const mitk::UnstructuredGrid &other) :
 BaseData(other),
 m_CalculateBoundingBox( other.m_CalculateBoundingBox ),
 m_LargestPossibleRegion(other.m_LargestPossibleRegion)
 {
   if(!other.m_Initialized)
   {
     this->InitializeEmpty();
   }
   else
   {
     m_GridSeries = other.m_GridSeries;
     m_Initialized = other.m_Initialized;
   }
   this->SetRequestedRegion( const_cast<mitk::UnstructuredGrid*>(&other) );
 }
 
 mitk::UnstructuredGrid::~UnstructuredGrid()
 {
   this->ClearData();
 }
 
 void mitk::UnstructuredGrid::UpdateOutputInformation()
 {
  if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
   if ( ( m_CalculateBoundingBox ) && ( m_GridSeries.size() > 0 ) )
     CalculateBoundingBox();
   else
-    GetTimeSlicedGeometry()->UpdateInformation();
+    GetTimeGeometry()->Update();
 }
 
 void mitk::UnstructuredGrid::CalculateBoundingBox()
 {
   //
   // first make sure, that the associated time sliced geometry has
   // the same number of geometry 3d's as vtkUnstructuredGrids are present
   //
-  mitk::TimeSlicedGeometry* timeGeometry = GetTimeSlicedGeometry();
-  if ( timeGeometry->GetTimeSteps() != m_GridSeries.size() )
+  TimeGeometry* timeGeometry = GetTimeGeometry();
+  if ( timeGeometry->GetNumberOfTimeSteps() != m_GridSeries.size() )
   {
-    itkExceptionMacro(<<"timeGeometry->GetTimeSteps() != m_GridSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
+    itkExceptionMacro(<<"timeGeometry->GetNumberOfTimeSteps() != m_GridSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
   }
 
   //
   // Iterate over the vtkUnstructuredGrids and update the Geometry
   // information of each of the items.
   //
   for ( unsigned int i = 0 ; i < m_GridSeries.size() ; ++i )
   {
     vtkUnstructuredGrid* grid = m_GridSeries[ i ];
     vtkFloatingPointType bounds[ ] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
     if ( ( grid != 0 ) && ( grid->GetNumberOfCells() > 0 ) )
     {
       grid->Update();
       grid->ComputeBounds();
       grid->GetBounds( bounds );
     }
-    mitk::Geometry3D::Pointer g3d = timeGeometry->GetGeometry3D( i );
+    mitk::Geometry3D::Pointer g3d = timeGeometry->GetGeometryForTimeStep( i );
     assert( g3d.IsNotNull() );
     g3d->SetFloatBounds( bounds );
   }
-  timeGeometry->UpdateInformation();
+  timeGeometry->Update();
 
-  mitk::BoundingBox::Pointer bb = const_cast<mitk::BoundingBox*>( timeGeometry->GetBoundingBox() );
+  mitk::BoundingBox::Pointer bb = const_cast<mitk::BoundingBox*>( timeGeometry->GetBoundingBoxInWorld() );
   itkDebugMacro( << "boundingbox min: "<< bb->GetMinimum());
   itkDebugMacro( << "boundingbox max: "<< bb->GetMaximum());
   m_CalculateBoundingBox = false;
 }
 
 
 void mitk::UnstructuredGrid::SetRequestedRegionToLargestPossibleRegion()
 {
   m_RequestedRegion = GetLargestPossibleRegion();
 }
 
 bool mitk::UnstructuredGrid::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3);
 
   if(((RegionType::IndexValueType)m_GridSeries.size()) < end)
     return true;
 
   for( RegionType::IndexValueType t=m_RequestedRegion.GetIndex(3); t < end; ++t )
     if(m_GridSeries[t] == 0)
       return true;
 
   return false;
 }
 
 bool mitk::UnstructuredGrid::VerifyRequestedRegion()
 {
   if( (m_RequestedRegion.GetIndex(3)>=0) &&
       (m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3)<=m_GridSeries.size()) )
     return true;
 
   return false;
 }
 
 void mitk::UnstructuredGrid::SetRequestedRegion(const itk::DataObject *data )
 {
   const mitk::UnstructuredGrid *gridData;
 
   gridData = dynamic_cast<const mitk::UnstructuredGrid*>(data);
 
   if (gridData)
   {
     m_RequestedRegion = gridData->GetRequestedRegion();
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(UnstructuredGrid*).name() );
   }
 }
 
 void mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType *region)  //by arin
 {
   if(region != 0)
   {
     m_RequestedRegion = *region;
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(UnstructuredGrid*).name() );
   }
 }
 
 void mitk::UnstructuredGrid::CopyInformation( const itk::DataObject * data )
 {
   Superclass::CopyInformation(data);
 }
 
 void mitk::UnstructuredGrid::Update()
 {
   if ( GetSource().IsNull() )
   {
     for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin() ; it != m_GridSeries.end() ; ++it )
     {
       if ( ( *it ) != 0 )
         ( *it )->Update();
     }
   }
   Superclass::Update();
 }
diff --git a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
index 5c4b5f310d..39362822af 100644
--- a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
+++ b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
@@ -1,112 +1,112 @@
 /*===================================================================
 
 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_UNSTRUCTURED_GRID_H_
 #define _MITK_UNSTRUCTURED_GRID_H_
 
 #include "mitkBaseData.h"
 #include "MitkExtExports.h"
 #include "itkImageRegion.h"
 
 class vtkUnstructuredGrid;
 
 namespace mitk {
 
 //##Documentation
 //## @brief Class for storing unstructured grids (vtkUnstructuredGrid)
 //## @ingroup Data
 class MitkExt_EXPORT UnstructuredGrid : public BaseData
 {
 
 public:
   // not yet the best choice of a region-type for surfaces, but it works for the time being
   typedef itk::ImageRegion< 5 >  RegionType;
 
   mitkClassMacro(UnstructuredGrid, BaseData);
 
   itkNewMacro(Self);
 
   mitkCloneMacro(UnstructuredGrid);
 
   virtual void SetVtkUnstructuredGrid(vtkUnstructuredGrid* grid, unsigned int t = 0);
 
   virtual vtkUnstructuredGrid* GetVtkUnstructuredGrid(unsigned int t = 0);
 
   virtual void UpdateOutputInformation();
 
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   virtual bool VerifyRequestedRegion();
 
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
   virtual void SetRequestedRegion(UnstructuredGrid::RegionType *region);
 
   virtual void CopyInformation(const itk::DataObject *data);
 
   virtual void Update();
 
   // Initialize should not be called manually;
   // The polydata vector is initialized automatically when enlarged;
   virtual void Expand( unsigned int timeSteps = 1 );
 
   const RegionType& GetLargestPossibleRegion() const
   {
     m_LargestPossibleRegion.SetIndex(3, 0);
-    m_LargestPossibleRegion.SetSize(3, GetTimeSlicedGeometry()->GetTimeSteps());
+    m_LargestPossibleRegion.SetSize(3, GetTimeGeometry()->GetNumberOfTimeSteps());
     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;
   }
 
   void CalculateBoundingBox();
 
 protected:
 
   typedef std::vector< vtkUnstructuredGrid* > VTKUnstructuredGridSeries;
 
   UnstructuredGrid();
 
   UnstructuredGrid(const mitk::UnstructuredGrid & other);
 
   virtual ~UnstructuredGrid();
 
   virtual void ClearData();
 
   virtual void InitializeEmpty();
 
   VTKUnstructuredGridSeries m_GridSeries;
 
   mutable RegionType m_LargestPossibleRegion;
 
   RegionType m_RequestedRegion;
 
   bool m_CalculateBoundingBox;
 };
 
 } // namespace mitk
 
 #endif /* _MITK_UNSTRUCTURED_GRID_H_ */
diff --git a/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx b/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
index 9479f2d3bd..4b9b0ec1b7 100644
--- a/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
+++ b/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
@@ -1,205 +1,205 @@
 /*===================================================================
 
 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_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 #define _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 
 #include <itkLightObject.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkLinearTransform.h>
 #include <vtkTransformFilter.h>
 #include <vtkUnstructuredGridWriter.h>
 #include <vtkXMLUnstructuredGridWriter.h>
 #include <vtkXMLPUnstructuredGridWriter.h>
 
 #include <sstream>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <stdio.h>
 
 namespace mitk {
 
 template<class VTKWRITER>
 UnstructuredGridVtkWriter<VTKWRITER>::UnstructuredGridVtkWriter()
   : m_Success(false)
 {
   this->SetNumberOfRequiredInputs(1);
 }
 
 template<class VTKWRITER>
 UnstructuredGridVtkWriter<VTKWRITER>::~UnstructuredGridVtkWriter()
 {
 
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::GenerateData()
 {
   m_Success = false;
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   mitk::UnstructuredGrid::Pointer input = const_cast<mitk::UnstructuredGrid*>(this->GetInput());
 
   if (input.IsNull())
   {
     itkWarningMacro( << "Sorry, input to mitk::UnstructuredGridVtkWriter is NULL");
     return;
   }
 
   VTKWRITER* unstructuredGridWriter = VTKWRITER::New();
   vtkTransformFilter* transformPointSet = vtkTransformFilter::New();
   vtkUnstructuredGrid * unstructuredGrid;
   Geometry3D* geometry;
 
-  if(input->GetTimeSlicedGeometry()->GetTimeSteps()>1)
+  if(input->GetTimeGeometry()->GetNumberOfTimeSteps()>1)
   {
 
     int t, timesteps;
 
-    timesteps = input->GetTimeSlicedGeometry()->GetTimeSteps();
+    timesteps = input->GetTimeGeometry()->GetNumberOfTimeSteps();
     for(t = 0; t < timesteps; ++t)
     {
       std::ostringstream filename;
       geometry = input->GetGeometry(t);
-      if(input->GetTimeSlicedGeometry()->IsValidTime(t))
+      if(input->GetTimeGeometry()->IsValidTimeStep(t))
       {
         const mitk::TimeBounds& timebounds = geometry->GetTimeBounds();
         filename <<  m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << GetDefaultExtension();
       }
       else
       {
-        itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of unstructured grid " << filename << ".");
+        itkWarningMacro(<<"Error on write: TimeGeometry invalid of unstructured grid " << filename << ".");
         filename <<  m_FileName.c_str() << "_T" << t << GetDefaultExtension();
       }
       geometry->TransferItkToVtkTransform();
       transformPointSet->SetInput(input->GetVtkUnstructuredGrid(t));
       transformPointSet->SetTransform(geometry->GetVtkTransform());
       transformPointSet->UpdateWholeExtent();
       unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
 
       unstructuredGridWriter->SetFileName(filename.str().c_str());
       unstructuredGridWriter->SetInput(unstructuredGrid);
 
       ExecuteWrite( unstructuredGridWriter );
     }
   }
   else
   {
     geometry = input->GetGeometry();
     geometry->TransferItkToVtkTransform();
     transformPointSet->SetInput(input->GetVtkUnstructuredGrid());
     transformPointSet->SetTransform(geometry->GetVtkTransform());
     transformPointSet->UpdateWholeExtent();
     unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
 
     unstructuredGridWriter->SetFileName(m_FileName.c_str());
     unstructuredGridWriter->SetInput(unstructuredGrid);
 
     ExecuteWrite( unstructuredGridWriter );
   }
   transformPointSet->Delete();
   unstructuredGridWriter->Delete();
 
   m_Success = true;
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::ExecuteWrite( VTKWRITER* vtkWriter )
 {
   struct stat fileStatus;
   time_t timeBefore=0;
   if (!stat(vtkWriter->GetFileName(), &fileStatus))
   {
     timeBefore = fileStatus.st_mtime;
   }
   if (!vtkWriter->Write())
   {
     itkExceptionMacro( << "Error during unstructured grid writing.");
   }
 
   // check if file can be written because vtkWriter doesn't check that
   if (stat(vtkWriter->GetFileName(), &fileStatus) || (timeBefore == fileStatus.st_mtime))
   {
     itkExceptionMacro(<<"Error during unstructured grid writing: file could not be written");
   }
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::SetInput(BaseData *input)
 {
   this->ProcessObject::SetNthInput(0, input);
 }
 
 template<class VTKWRITER>
 const UnstructuredGrid* UnstructuredGridVtkWriter<VTKWRITER>::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
   else
   {
     return dynamic_cast<UnstructuredGrid*>(this->ProcessObject::GetInput(0));
   }
 }
 
 template<class VTKWRITER>
 bool UnstructuredGridVtkWriter<VTKWRITER>::CanWriteBaseDataType(BaseData::Pointer data)
 {
   return (dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()) != 0);
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::DoWrite(BaseData::Pointer data)
 {
   if (CanWriteBaseDataType(data))
   {
     this->SetInput(dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()));
     this->Update();
   }
 }
 
 template<class VTKWRITER>
 std::vector<std::string> UnstructuredGridVtkWriter<VTKWRITER>::GetPossibleFileExtensions()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultFilename()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetFileDialogPattern()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultExtension()
 {
   throw std::exception(); // no specialization available!
 }
 
 }
 
 #endif
diff --git a/Modules/MitkExt/Interactions/mitkAffineInteractor3D.cpp b/Modules/MitkExt/Interactions/mitkAffineInteractor3D.cpp
index 210590de2a..20945e0036 100644
--- a/Modules/MitkExt/Interactions/mitkAffineInteractor3D.cpp
+++ b/Modules/MitkExt/Interactions/mitkAffineInteractor3D.cpp
@@ -1,492 +1,488 @@
 /*===================================================================
 
 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 )
 {
   m_OriginalGeometry = Geometry3D::New();
 
   // 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 Geometry2D of the window the user interacts with (for 2D point
   //  // projection)
   //  BaseRenderer *renderer = stateEvent->GetEvent()->GetSender();
   //  const Geometry2D *projectionPlane = renderer->GetCurrentWorldGeometry2D();
 
   //  // 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< Geometry3D * >(
         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 )
         {
           vtkFloatingPointType 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 );
           Geometry3D::Pointer newGeometry = static_cast< Geometry3D * >(
             m_OriginalGeometry->Clone().GetPointer() );
           newGeometry->ExecuteOperation( &op );
-          mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry = data->GetTimeSlicedGeometry();
-          if (timeSlicedGeometry.IsNotNull())
-          {
-            timeSlicedGeometry->SetGeometry3D( newGeometry, timeStep );
-          }
+          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/MitkExt/Rendering/mitkMeshMapper2D.cpp b/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
index 4b29bdf907..7ba66c362a 100644
--- a/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
+++ b/Modules/MitkExt/Rendering/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 TimeSlicedGeometry of the input object
-    const TimeSlicedGeometry* inputTimeGeometry = input->GetTimeSlicedGeometry();
-    if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
+    // Get the TimeGeometry of the input object
+    const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
+    if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
     {
       return;
     }
 
     //
     // get the world time
     //
     const Geometry2D* worldGeometry = renderer->GetCurrentWorldGeometry2D();
     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->MSToTimeStep( time );
-    if ( inputTimeGeometry->IsValidTime( timeStep ) == false )
+      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());
 
     //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;      glVertex2fv(&tmp[0]);
                 tmp=pt2d+horz+vert;      glVertex2fv(&tmp[0]);
                 tmp=pt2d+horz-vert;      glVertex2fv(&tmp[0]);
                 tmp=pt2d-horz-vert;      glVertex2fv(&tmp[0]);
               glEnd ();
             }
             break;
           case PTUNDEFINED:
             {
               //a diamond around the point
               glBegin (GL_LINE_LOOP);
                 tmp=pt2d-horz;      glVertex2fv(&tmp[0]);
                 tmp=pt2d+vert;      glVertex2fv(&tmp[0]);
                 tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
                 tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
               glEnd ();
             }
             break;
           default:
             break;
           }//switch
 
           //the actual point
           glBegin (GL_POINTS);
             tmp=pt2d;             glVertex2fv(&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;      glVertex2fv(&tmp[0]);
                 tmp=pt2d+horz+vert;      glVertex2fv(&tmp[0]);
                 tmp=pt2d+horz-vert;      glVertex2fv(&tmp[0]);
                 tmp=pt2d-horz-vert;      glVertex2fv(&tmp[0]);
               glEnd ();
             }
           case PTUNDEFINED:
             {
               //drawing crosses
               glBegin (GL_LINES);
                   tmp=pt2d-horz;      glVertex2fv(&tmp[0]);
                   tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
                   tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
                   tmp=pt2d+vert;      glVertex2fv(&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);
 
         intersectionPoints.clear();
         intersectionPoints.reserve(numOfPointsInCell);
 
         first = true;
 
         while(cellIdIt != cellIdEnd)
         {
           lastPoint3D = thisPoint;
 
           thisPoint = input->GetPoint(*cellIdIt);
 
           //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);
                   glVertex2fv(&(*lastPoint)[0]);
                   glVertex2fv(&pt2d[0]);
                 glEnd ();
               }
               else //if not selected
               {
                 glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
                 //drawing crosses
                 glBegin (GL_LINES);
                   glVertex2fv(&(*lastPoint)[0]);
                   glVertex2fv(&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);
                 glVertex2fv(&(*lastPoint)[0]);
                 glVertex2fv(&(*firstOfCell)[0]);
               glEnd ();
             }
             else
             {
               glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
               glBegin (GL_LINES);
                 glVertex2fv(&(*lastPoint)[0]);
                 glVertex2fv(&(*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
           }
           float 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]; glVertex2fv(p);
               ++it;
               displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
               p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(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]; glVertex2fv(p);
               p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(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/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp b/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp
index aa9111be24..fd8543fe08 100644
--- a/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp
@@ -1,425 +1,425 @@
 /*===================================================================
 
 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 "mitkUnstructuredGridVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkColorProperty.h"
 //#include "mitkLookupTableProperty.h"
 #include "mitkGridRepresentationProperty.h"
 #include "mitkGridVolumeMapperProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 
 #include "mitkDataStorage.h"
 
 #include "mitkSurfaceVtkMapper3D.h"
 
 #include <vtkUnstructuredGrid.h>
 #include <vtkVolume.h>
 #include <vtkVolumeProperty.h>
 #include <vtkProperty.h>
 
 #include <vtkPlanes.h>
 
 
 
 const mitk::UnstructuredGrid* mitk::UnstructuredGridVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::UnstructuredGrid * > ( GetDataNode()->GetData() );
 }
 
 
 mitk::UnstructuredGridVtkMapper3D::UnstructuredGridVtkMapper3D()
 {
 
   m_VtkTriangleFilter = vtkDataSetTriangleFilter::New();
 
   m_Assembly = vtkAssembly::New();
 
   m_Volume = vtkVolume::New();
   m_Actor = vtkActor::New();
   m_ActorWireframe = vtkActor::New();
 
   m_VtkDataSetMapper = vtkUnstructuredGridMapper::New();
   m_VtkDataSetMapper->SetResolveCoincidentTopologyToPolygonOffset();
   m_VtkDataSetMapper->SetResolveCoincidentTopologyPolygonOffsetParameters(0,1);
   m_Actor->SetMapper(m_VtkDataSetMapper);
 
   m_VtkDataSetMapper2 = vtkUnstructuredGridMapper::New();
   m_VtkDataSetMapper2->SetResolveCoincidentTopologyToPolygonOffset();
   m_VtkDataSetMapper2->SetResolveCoincidentTopologyPolygonOffsetParameters(1,1);
   m_ActorWireframe->SetMapper(m_VtkDataSetMapper2);
   m_ActorWireframe->GetProperty()->SetRepresentationToWireframe();
 
   m_Assembly->AddPart(m_Actor);
   m_Assembly->AddPart(m_ActorWireframe);
   m_Assembly->AddPart(m_Volume);
 
   m_VtkVolumeRayCastMapper = 0;
   m_VtkPTMapper = 0;
   m_VtkVolumeZSweepMapper = 0;
 
   //m_GenerateNormals = false;
 }
 
 
 mitk::UnstructuredGridVtkMapper3D::~UnstructuredGridVtkMapper3D()
 {
 
   if (m_VtkTriangleFilter != 0)
     m_VtkTriangleFilter->Delete();
 
   if (m_VtkVolumeRayCastMapper != 0)
     m_VtkVolumeRayCastMapper->Delete();
 
   if (m_VtkVolumeZSweepMapper != 0)
     m_VtkVolumeZSweepMapper->Delete();
 
   if (m_VtkPTMapper != 0)
     m_VtkPTMapper->Delete();
 
   if (m_VtkDataSetMapper != 0)
     m_VtkDataSetMapper->Delete();
 
   if (m_VtkDataSetMapper2 != 0)
       m_VtkDataSetMapper2->Delete();
 
   if (m_Assembly != 0)
     m_Assembly->Delete();
 
   if (m_Actor != 0)
     m_Actor->Delete();
 
   if (m_ActorWireframe != 0)
       m_ActorWireframe->Delete();
 
   if (m_Volume != 0)
     m_Volume->Delete();
 
 }
 
 vtkProp* mitk::UnstructuredGridVtkMapper3D::GetVtkProp(mitk::BaseRenderer*  /*renderer*/)
 {
   return m_Assembly;
 }
 
 
 void mitk::UnstructuredGridVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
 
   mitk::DataNode::ConstPointer node = this->GetDataNode();
 
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   if(needGenerateData)
   {
     ls->UpdateGenerateDataTime();
 
     m_Assembly->VisibilityOn();
 
     m_ActorWireframe->GetProperty()->SetAmbient(1.0);
     m_ActorWireframe->GetProperty()->SetDiffuse(0.0);
     m_ActorWireframe->GetProperty()->SetSpecular(0.0);
 
     mitk::TransferFunctionProperty::Pointer transferFuncProp;
     if (node->GetProperty(transferFuncProp, "TransferFunction"))
     {
       mitk::TransferFunction::Pointer transferFunction = transferFuncProp->GetValue();
       if (transferFunction->GetColorTransferFunction()->GetSize() < 2)
       {
         mitk::UnstructuredGrid::Pointer input  = const_cast< mitk::UnstructuredGrid* >(this->GetInput());
         if (input.IsNull()) return;
 
         vtkUnstructuredGrid * grid = input->GetVtkUnstructuredGrid(this->GetTimestep());
         if (grid == 0) return;
 
         double* scalarRange = grid->GetScalarRange();
         vtkColorTransferFunction* colorFunc = transferFunction->GetColorTransferFunction();
         colorFunc->RemoveAllPoints();
         colorFunc->AddRGBPoint(scalarRange[0], 1, 0, 0);
         colorFunc->AddRGBPoint((scalarRange[0] + scalarRange[1])/2.0, 0, 1, 0);
         colorFunc->AddRGBPoint(scalarRange[1], 0, 0, 1);
       }
     }
   }
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if(!visible)
   {
     m_Assembly->VisibilityOff();
     return;
   }
 
   //
-  // get the TimeSlicedGeometry of the input object
+  // get the TimeGeometry of the input object
   //
   mitk::UnstructuredGrid::Pointer input  = const_cast< mitk::UnstructuredGrid* >( this->GetInput() );
 
   //
   // set the input-object at time t for the mapper
   //
   vtkUnstructuredGrid * grid = input->GetVtkUnstructuredGrid( this->GetTimestep() );
   if(grid == 0)
   {
     m_Assembly->VisibilityOff();
     return;
   }
 
   m_Assembly->VisibilityOn();
 
   m_VtkTriangleFilter->SetInput(grid);
   m_VtkDataSetMapper->SetInput(grid);
   m_VtkDataSetMapper2->SetInput(grid);
 
   bool clip = false;
   node->GetBoolProperty("enable clipping", clip);
   mitk::DataNode::Pointer bbNode = renderer->GetDataStorage()->GetNamedDerivedNode("Clipping Bounding Object", node);
   if (clip && bbNode.IsNotNull())
   {
     m_VtkDataSetMapper->SetBoundingObject(dynamic_cast<mitk::BoundingObject*>(bbNode->GetData()));
     m_VtkDataSetMapper2->SetBoundingObject(dynamic_cast<mitk::BoundingObject*>(bbNode->GetData()));
   }
   else
   {
     m_VtkDataSetMapper->SetBoundingObject(0);
     m_VtkDataSetMapper2->SetBoundingObject(0);
   }
 
   //
   // apply properties read from the PropertyList
   //
   ApplyProperties(0, renderer);
 }
 
 
 void mitk::UnstructuredGridVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
 {
   m_Assembly->VisibilityOff();
 }
 
 
 void mitk::UnstructuredGridVtkMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* renderer)
 {
   mitk::DataNode::Pointer node = this->GetDataNode();
   ApplyColorAndOpacityProperties(renderer, m_Actor);
   ApplyColorAndOpacityProperties(renderer, m_ActorWireframe);
 
   vtkVolumeProperty* volProp = m_Volume->GetProperty();
   vtkProperty* property = m_Actor->GetProperty();
   vtkProperty* wireframeProp = m_ActorWireframe->GetProperty();
 
   mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,property,renderer);
   mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,wireframeProp,renderer);
 
   mitk::TransferFunctionProperty::Pointer transferFuncProp;
   if (node->GetProperty(transferFuncProp, "TransferFunction", renderer))
   {
     mitk::TransferFunction::Pointer transferFunction = transferFuncProp->GetValue();
 
     volProp->SetColor(transferFunction->GetColorTransferFunction());
     volProp->SetScalarOpacity(transferFunction->GetScalarOpacityFunction());
     volProp->SetGradientOpacity(transferFunction->GetGradientOpacityFunction());
 
     m_VtkDataSetMapper->SetLookupTable(transferFunction->GetColorTransferFunction());
     m_VtkDataSetMapper2->SetLookupTable(transferFunction->GetColorTransferFunction());
   }
 
   bool isVolumeRenderingOn = false;
   node->GetBoolProperty("volumerendering", isVolumeRenderingOn, renderer);
 
   if (isVolumeRenderingOn)
   {
     m_Assembly->RemovePart(m_Actor);
     m_Assembly->RemovePart(m_ActorWireframe);
     m_Assembly->AddPart(m_Volume);
 
     mitk::GridVolumeMapperProperty::Pointer mapperProp;
     if (node->GetProperty(mapperProp, "volumerendering.mapper", renderer))
     {
       mitk::GridVolumeMapperProperty::IdType type = mapperProp->GetValueAsId();
       switch (type) {
         case mitk::GridVolumeMapperProperty::RAYCAST:
           if (m_VtkVolumeRayCastMapper == 0) {
             m_VtkVolumeRayCastMapper = vtkUnstructuredGridVolumeRayCastMapper::New();
             m_VtkVolumeRayCastMapper->SetInput(m_VtkTriangleFilter->GetOutput());
           }
           m_Volume->SetMapper(m_VtkVolumeRayCastMapper);
           break;
         case mitk::GridVolumeMapperProperty::PT:
           if (m_VtkPTMapper == 0) {
             m_VtkPTMapper = vtkProjectedTetrahedraMapper::New();
             m_VtkPTMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
           }
           m_Volume->SetMapper(m_VtkPTMapper);
           break;
         case mitk::GridVolumeMapperProperty::ZSWEEP:
           if (m_VtkVolumeZSweepMapper == 0) {
             m_VtkVolumeZSweepMapper = vtkUnstructuredGridVolumeZSweepMapper::New();
             m_VtkVolumeZSweepMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
           }
           m_Volume->SetMapper(m_VtkVolumeZSweepMapper);
           break;
       }
     }
   }
   else
   {
     m_Assembly->RemovePart(m_Volume);
     m_Assembly->AddPart(m_Actor);
     m_Assembly->RemovePart(m_ActorWireframe);
 
     mitk::GridRepresentationProperty::Pointer gridRepProp;
     if (node->GetProperty(gridRepProp, "grid representation", renderer))
     {
       mitk::GridRepresentationProperty::IdType type = gridRepProp->GetValueAsId();
       switch (type) {
         case mitk::GridRepresentationProperty::POINTS:
           property->SetRepresentationToPoints();
           break;
         case mitk::GridRepresentationProperty::WIREFRAME:
           property->SetRepresentationToWireframe();
           break;
         case mitk::GridRepresentationProperty::SURFACE:
           property->SetRepresentationToSurface();
           break;
       }
 
 //      if (type == mitk::GridRepresentationProperty::WIREFRAME_SURFACE)
 //      {
 //        m_Assembly->AddPart(m_ActorWireframe);
 //      }
     }
   }
 
 
 //   mitk::LevelWindow levelWindow;
 //   if(node->GetLevelWindow(levelWindow, renderer, "levelWindow"))
 //   {
 //     m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
 //   }
 //   else
 //   if(node->GetLevelWindow(levelWindow, renderer))
 //   {
 //     m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
 //   }
 //
 //   mitk::VtkRepresentationProperty* representationProperty;
 //   node->GetProperty(representationProperty, "material.representation", renderer);
 //   if ( representationProperty != NULL )
 //     m_Volume->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
 //
 //   mitk::VtkInterpolationProperty* interpolationProperty;
 //   node->GetProperty(interpolationProperty, "material.interpolation", renderer);
 //   if ( interpolationProperty != NULL )
 //     m_Volume->GetProperty()->SetInterpolation( interpolationProperty->GetVtkInterpolation() );
 //
 
    mitk::VtkScalarModeProperty* scalarMode = 0;
    if(node->GetProperty(scalarMode, "scalar mode", renderer))
    {
      if (m_VtkVolumeRayCastMapper)
        m_VtkVolumeRayCastMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
      if (m_VtkPTMapper)
        m_VtkPTMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
      if (m_VtkVolumeZSweepMapper)
        m_VtkVolumeZSweepMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
 
      m_VtkDataSetMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
      m_VtkDataSetMapper2->SetScalarMode(scalarMode->GetVtkScalarMode());
    }
    else
    {
      if (m_VtkVolumeRayCastMapper)
        m_VtkVolumeRayCastMapper->SetScalarModeToDefault();
      if (m_VtkPTMapper)
        m_VtkPTMapper->SetScalarModeToDefault();
      if (m_VtkVolumeZSweepMapper)
        m_VtkVolumeZSweepMapper->SetScalarModeToDefault();
 
      m_VtkDataSetMapper->SetScalarModeToDefault();
      m_VtkDataSetMapper2->SetScalarModeToDefault();
    }
 
    bool scalarVisibility = true;
    node->GetBoolProperty("scalar visibility", scalarVisibility, renderer);
    m_VtkDataSetMapper->SetScalarVisibility(scalarVisibility ? 1 : 0);
    m_VtkDataSetMapper2->SetScalarVisibility(scalarVisibility ? 1 : 0);
 
 //   double scalarRangeLower = std::numeric_limits<double>::min();
 //   double scalarRangeUpper = std::numeric_limits<double>::max();
 //   mitk::DoubleProperty* lowerRange = 0;
 //   if (node->GetProperty(lowerRange, "scalar range min", renderer))
 //   {
 //     scalarRangeLower = lowerRange->GetValue();
 //   }
 //   mitk::DoubleProperty* upperRange = 0;
 //   if (node->GetProperty(upperRange, "scalar range max", renderer))
 //   {
 //     scalarRangeUpper = upperRange->GetValue();
 //   }
 //   m_VtkDataSetMapper->SetScalarRange(scalarRangeLower, scalarRangeUpper);
 //   m_VtkDataSetMapper2->SetScalarRange(scalarRangeLower, scalarRangeUpper);
 
 
 //   bool colorMode = false;
 //   node->GetBoolProperty("color mode", colorMode);
 //   m_VtkVolumeRayCastMapper->SetColorMode( (colorMode ? 1 : 0) );
 
 //   float scalarsMin = 0;
 //   if (dynamic_cast<mitk::FloatProperty *>(node->GetProperty("ScalarsRangeMinimum").GetPointer()) != NULL)
 //     scalarsMin = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("ScalarsRangeMinimum").GetPointer())->GetValue();
 
 //   float scalarsMax = 1.0;
 //   if (dynamic_cast<mitk::FloatProperty *>(node->GetProperty("ScalarsRangeMaximum").GetPointer()) != NULL)
 //     scalarsMax = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("ScalarsRangeMaximum").GetPointer())->GetValue();
 
 //   m_VtkVolumeRayCastMapper->SetScalarRange(scalarsMin,scalarsMax);
 
 }
 
 void mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
 
   SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node, renderer, overwrite);
 
   node->AddProperty("grid representation", GridRepresentationProperty::New(), renderer, overwrite);
   node->AddProperty("volumerendering", BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("volumerendering.mapper", GridVolumeMapperProperty::New(), renderer, overwrite);
   node->AddProperty("scalar mode", VtkScalarModeProperty::New(0), renderer, overwrite);
   node->AddProperty("scalar visibility", BoolProperty::New(true), renderer, overwrite);
   //node->AddProperty("scalar range min", DoubleProperty::New(std::numeric_limits<double>::min()), renderer, overwrite);
   //node->AddProperty("scalar range max", DoubleProperty::New(std::numeric_limits<double>::max()), renderer, overwrite);
   node->AddProperty("outline polygons", BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("color", ColorProperty::New(1.0f, 1.0f, 1.0f), renderer, overwrite);
   node->AddProperty("line width", IntProperty::New(1), renderer, overwrite);
 
   if(overwrite || node->GetProperty("TransferFunction", renderer) == 0)
   {
     // add a default transfer function
     mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
     //tf->GetColorTransferFunction()->RemoveAllPoints();
     node->SetProperty ("TransferFunction", mitk::TransferFunctionProperty::New(tf.GetPointer()));
   }
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
diff --git a/Modules/MitkExt/Rendering/mitkVectorImageMapper2D.cpp b/Modules/MitkExt/Rendering/mitkVectorImageMapper2D.cpp
index e4764abbd4..00066f6b04 100644
--- a/Modules/MitkExt/Rendering/mitkVectorImageMapper2D.cpp
+++ b/Modules/MitkExt/Rendering/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 <vtkPolyDataSource.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::Geometry2D*>( renderer->GetCurrentWorldGeometry2D() ) );
   assert( worldPlaneGeometry2D.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;
   Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
   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 ;
   }
 
   vtkFloatingPointType vp[ 3 ], vp_slice[ 3 ], vnormal[ 3 ];
   vnl2vtk( point.Get_vnl_vector(), vp );
   vnl2vtk( normal.Get_vnl_vector(), 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->SetInput( 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);
     vtkFloatingPointType inVector[ 3 ], outVector[3], wnormal[3]; //, tmpVector[ 3 ], outVector[ 3 ];
     vtkFloatingPointType k = 0.0;
     vnl2vtk( normal.Get_vnl_vector(), 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->SetSource( glyphSource->GetOutput() );
     glyphGenerator->SetInputConnection(cuttedPlane->GetProducerPort());
     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 );
 
     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 Geometry2D* worldGeometry, const DisplayGeometry* displayGeometry, vtkLinearTransform* vtktransform, mitk::BaseRenderer*  /*renderer*/, vtkScalarsToColors *lut, mitk::Color color, float lwidth, vtkFloatingPointType *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;
 
   vtkFloatingPointType offset[3];
   for (unsigned int i = 0; i < 3; ++i)
   {
     offset[i] = 0;
   }
 
   vtkIdType numCells = glyphs->GetNumberOfCells();
   for ( vtkIdType cellId = 0; cellId < numCells; ++cellId )
   {
     vtkFloatingPointType vp[ 3 ];
 
     cell = glyphs->GetCell( cellId );
     idList = cell->GetPointIds();
 
     int numPoints = idList->GetNumberOfIds();
 
     if(numPoints == 1)
     {
       //take transformation via vtktransform into account
       vtkFloatingPointType 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];
 
         vtkFloatingPointType 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
           vtkFloatingPointType * 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 TimeSlicedGeometry of the input object
+  // get the TimeGeometry of the input object
   //
-  const TimeSlicedGeometry * dataTimeGeometry = data->GetUpdatedTimeSlicedGeometry();
-  if ( ( dataTimeGeometry == NULL ) || ( dataTimeGeometry->GetTimeSteps() == 0 ) )
+  const TimeGeometry * dataTimeGeometry = data->GetUpdatedTimeGeometry();
+  if ( ( dataTimeGeometry == NULL ) || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
   {
-    itkWarningMacro( << "geometry of the given data object isn't a mitk::TimeSlicedGeometry, or the number of time steps is 0!" );
+    itkWarningMacro( << "The given object is missing a mitk::TimeGeometry, or the number of time steps is 0!" );
     return 0;
   }
 
   //
   // get the world time
   //
   Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
   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->MSToTimeStep( time );
-  if ( dataTimeGeometry->IsValidTime( timestep ) == false )
+    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/DataManagement/mitkPlanarFigure.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
index 0ffe539b13..fe7a49fe64 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
@@ -1,707 +1,713 @@
 /*===================================================================
 
 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 "mitkGeometry2D.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_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->InitializeTimeSlicedGeometry( 1 );
+  this->InitializeTimeGeometry( 1 );
 }
 
 
 mitk::PlanarFigure::~PlanarFigure()
 {
 }
 
 
 void mitk::PlanarFigure::SetGeometry2D( mitk::Geometry2D *geometry )
 {
   this->SetGeometry( geometry );
-  m_Geometry2D = geometry;
+  m_Geometry2D = dynamic_cast<Geometry2D *>(GetGeometry(0));//geometry;
 }
 
 
 const mitk::Geometry2D *mitk::PlanarFigure::GetGeometry2D() const
 {
   return m_Geometry2D;
 }
 
 
 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) )
   {
     m_Geometry2D->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 Geometry2D defines a fixed
   // frame (= bounds) for the planar figure.
   Superclass::UpdateOutputInformation();
-  this->GetTimeSlicedGeometry()->UpdateInformation();
+  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 )
   {
     return point;
   }
 
   Point2D indexPoint;
   m_Geometry2D->WorldToIndex( point, indexPoint );
 
   BoundingBox::BoundsArrayType bounds = m_Geometry2D->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 );
 
   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::InitializeTimeSlicedGeometry( unsigned int timeSteps )
 {
-  mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
+  InitializeTimeGeometry(timeSteps);
+}
 
+void mitk::PlanarFigure::InitializeTimeGeometry( unsigned int timeSteps )
+{
   mitk::Geometry2D::Pointer geometry2D = mitk::Geometry2D::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...
-  timeGeometry->InitializeEvenlyTimed( geometry2D, timeSteps );
+  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());
 }
 
 
 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
-  SetGeometry2D((mitk::Geometry2D*)oldFigure->m_Geometry2D->Clone().GetPointer());
+  Geometry3D::Pointer affineGeometry = oldFigure->m_Geometry2D->Clone();
+  SetGeometry2D(dynamic_cast<mitk::Geometry2D*>(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 22a892d74b..fda60de81b 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
@@ -1,410 +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 "PlanarFigureExports.h"
 #include "mitkBaseData.h"
 #include "mitkCommon.h"
 
 #include <deque>
 
 
 namespace mitk
 {
 
 class Geometry2D;
 
 /**
  * \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 PlanarFigure_EXPORT PlanarFigure : public BaseData
 {
 public:
   mitkClassMacro( PlanarFigure, BaseData )
 
   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::Geometry2D *geometry );
 
 
   /** \brief Returns (previously set) 2D geometry of this figure. */
   virtual const Geometry2D *GetGeometry2D() 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. */
   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();
 
   /** \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 TimeSlicedGeometry describing the (time-resolved)
-   * geometry of this figure. Note that each time step holds one Geometry2D. */
-  virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 );
+  /** \brief Initializes the TimeGeometry describing the (time-resolved)
+   * geometry of this figure. Note that each time step holds one Geometry2D.
+   *
+   * \deprecatedSince{2013_06} Please use InitializeTimeGeometry instead: For additional information see  @TimeGeometryGuide@
+   */
+   DEPRECATED(virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 ));
+
+  /** \brief Initializes the TimeGeometry describing the (time-resolved)
+   * geometry of this figure. Note that each time step holds one Geometry2D.
+   */
+  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;
   };
 
   Geometry2D *m_Geometry2D;
 
 
   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/IO/mitkPlanarFigureReader.cpp b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
index da351f5580..41df419466 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
@@ -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.
 
 ===================================================================*/
 
 
 #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 "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
     {
       // 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;
         }
       }
     }
 
 
     // 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::AffineGeometryFrame3D::TransformType TransformType;
+        typedef mitk::Geometry3D::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::AffineGeometryFrame3D::TransformType TransformType;
+        typedef mitk::Geometry3D::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::Geometry3D::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);
       }
       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->QueryFloatAttribute("x", &x) == TIXML_WRONG_TYPE)
           return; // TODO: can we do a better error handling?
         if (vertElement->QueryFloatAttribute("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->QueryFloatAttribute("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->QueryFloatAttribute("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->QueryFloatAttribute("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->QueryFloatAttribute("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->QueryFloatAttribute("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->QueryFloatAttribute("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->QueryFloatAttribute( 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 e39574a604..f2b1cbc8d4 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());
     if (planeGeo != NULL)
     {
       // Write parameters of IndexToWorldTransform of the PlaneGeometry
-      typedef mitk::AffineGeometryFrame3D::TransformType TransformType;
+      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/Testing/mitkPlanarFigureIOTest.cpp b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp
index f49d3b2e90..898266f001 100644
--- a/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp
+++ b/Modules/PlanarFigure/Testing/mitkPlanarFigureIOTest.cpp
@@ -1,594 +1,594 @@
 /*===================================================================
 
 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>
 
 
 /** \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->PlaceFigure( p0 );
     planarAngle->SetCurrentControlPoint( p1 );
     planarAngle->AddControlPoint( p2 );
     planarFigures.push_back( planarAngle.GetPointer() );
 
     // Create PlanarCircle
     mitk::PlanarCircle::Pointer planarCircle = mitk::PlanarCircle::New();
     planarCircle->SetGeometry2D( planeGeometry );
     planarCircle->PlaceFigure( p0 );
     planarCircle->SetCurrentControlPoint( p1 );
     planarFigures.push_back( planarCircle.GetPointer() );
 
     // Create PlanarCross
     mitk::PlanarCross::Pointer planarCross = mitk::PlanarCross::New();
     planarCross->SetSingleLineMode( false );
     planarCross->SetGeometry2D( planeGeometry );
     planarCross->PlaceFigure( p0 );
     planarCross->SetCurrentControlPoint( p1 );
     planarCross->AddControlPoint( p2 );
     planarCross->AddControlPoint( p3 );
     planarFigures.push_back( planarCross.GetPointer() );
 
     // Create PlanarFourPointAngle
     mitk::PlanarFourPointAngle::Pointer planarFourPointAngle = mitk::PlanarFourPointAngle::New();
     planarFourPointAngle->SetGeometry2D( planeGeometry );
     planarFourPointAngle->PlaceFigure( p0 );
     planarFourPointAngle->SetCurrentControlPoint( p1 );
     planarFourPointAngle->AddControlPoint( p2 );
     planarFourPointAngle->AddControlPoint( p3 );
     planarFigures.push_back( planarFourPointAngle.GetPointer() );
 
     // Create PlanarLine
     mitk::PlanarLine::Pointer planarLine = mitk::PlanarLine::New();
     planarLine->SetGeometry2D( planeGeometry );
     planarLine->PlaceFigure( p0 );
     planarLine->SetCurrentControlPoint( p1 );
     planarFigures.push_back( planarLine.GetPointer() );
 
     // Create PlanarPolygon
     mitk::PlanarPolygon::Pointer planarPolygon = mitk::PlanarPolygon::New();
     planarPolygon->SetClosed( false );
     planarPolygon->SetGeometry2D( planeGeometry );
     planarPolygon->PlaceFigure( p0 );
     planarPolygon->SetCurrentControlPoint( p1 );
     planarPolygon->AddControlPoint( p2 );
     planarPolygon->AddControlPoint( p3 );
     planarFigures.push_back( planarPolygon.GetPointer() );
 
     // Create PlanarSubdivisionPolygon
     mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygon = mitk::PlanarSubdivisionPolygon::New();
     planarSubdivisionPolygon->SetClosed( false );
     planarSubdivisionPolygon->SetGeometry2D( planeGeometry );
     planarSubdivisionPolygon->PlaceFigure( p0 );
     planarSubdivisionPolygon->SetCurrentControlPoint( p1 );
     planarSubdivisionPolygon->AddControlPoint( p2 );
     planarSubdivisionPolygon->AddControlPoint( p3 );
     planarFigures.push_back( planarSubdivisionPolygon.GetPointer() );
 
     // Create PlanarRectangle
     mitk::PlanarRectangle::Pointer planarRectangle = mitk::PlanarRectangle::New();
     planarRectangle->SetGeometry2D( planeGeometry );
     planarRectangle->PlaceFigure( p0 );
     planarRectangle->SetCurrentControlPoint( p1 );
     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->PlaceFigure( p0precise );
     nochncross->SetCurrentControlPoint( p1precise );
     nochncross->AddControlPoint( p2precise );
     nochncross->AddControlPoint( p3precise );
     planarFigures.push_back( nochncross.GetPointer() );
 
     // Create PlanarAngle
     mitk::PlanarAngle::Pointer planarAnglePrecise = mitk::PlanarAngle::New();
     planarAnglePrecise->SetGeometry2D( preciseGeometry );
     planarAnglePrecise->PlaceFigure( p0precise );
     planarAnglePrecise->SetCurrentControlPoint( p1precise );
     planarAnglePrecise->AddControlPoint( p2precise );
     planarFigures.push_back( planarAnglePrecise.GetPointer() );
 
     // Create PlanarCircle
     mitk::PlanarCircle::Pointer planarCirclePrecise = mitk::PlanarCircle::New();
     planarCirclePrecise->SetGeometry2D( preciseGeometry );
     planarCirclePrecise->PlaceFigure( p0precise );
     planarCirclePrecise->SetCurrentControlPoint( p1precise );
     planarFigures.push_back( planarCirclePrecise.GetPointer() );
 
     // Create PlanarFourPointAngle
     mitk::PlanarFourPointAngle::Pointer planarFourPointAnglePrecise = mitk::PlanarFourPointAngle::New();
     planarFourPointAnglePrecise->SetGeometry2D( preciseGeometry );
     planarFourPointAnglePrecise->PlaceFigure( p0precise );
     planarFourPointAnglePrecise->SetCurrentControlPoint( p1precise );
     planarFourPointAnglePrecise->AddControlPoint( p2precise );
     planarFourPointAnglePrecise->AddControlPoint( p3precise );
     planarFigures.push_back( planarFourPointAnglePrecise.GetPointer() );
 
     // Create PlanarLine
     mitk::PlanarLine::Pointer planarLinePrecise = mitk::PlanarLine::New();
     planarLinePrecise->SetGeometry2D( preciseGeometry );
     planarLinePrecise->PlaceFigure( p0precise );
     planarLinePrecise->SetCurrentControlPoint( p1precise );
     planarFigures.push_back( planarLinePrecise.GetPointer() );
 
     // Create PlanarPolygon
     mitk::PlanarPolygon::Pointer planarPolygonPrecise = mitk::PlanarPolygon::New();
     planarPolygonPrecise->SetClosed( false );
     planarPolygonPrecise->SetGeometry2D( preciseGeometry );
     planarPolygonPrecise->PlaceFigure( p0precise );
     planarPolygonPrecise->SetCurrentControlPoint( p1precise );
     planarPolygonPrecise->AddControlPoint( p2precise );
     planarPolygonPrecise->AddControlPoint( p3precise );
     planarFigures.push_back( planarPolygonPrecise.GetPointer() );
 
     // Create PlanarSubdivisionPolygon
     mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygonPrecise = mitk::PlanarSubdivisionPolygon::New();
     planarSubdivisionPolygonPrecise->SetClosed( false );
     planarSubdivisionPolygonPrecise->SetGeometry2D( preciseGeometry );
     planarSubdivisionPolygonPrecise->PlaceFigure( p0precise );
     planarSubdivisionPolygonPrecise->SetCurrentControlPoint( p1precise );
     planarSubdivisionPolygonPrecise->AddControlPoint( p2precise );
     planarSubdivisionPolygonPrecise->AddControlPoint( p3precise );
     planarFigures.push_back( planarSubdivisionPolygonPrecise.GetPointer() );
 
     // Create PlanarRectangle
     mitk::PlanarRectangle::Pointer planarRectanglePrecise = mitk::PlanarRectangle::New();
     planarRectanglePrecise->SetGeometry2D( preciseGeometry );
     planarRectanglePrecise->PlaceFigure( p0precise );
     planarRectanglePrecise->SetCurrentControlPoint( p1precise );
     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;
       if(strcmp((*it1)->GetNameOfClass(), "PlanarAngle") == 0)
       {
         copiedFigure    = mitk::PlanarAngle::New();
       }
       if(strcmp((*it1)->GetNameOfClass(), "PlanarCircle") == 0)
       {
         copiedFigure    = mitk::PlanarCircle::New();
       }
       if(strcmp((*it1)->GetNameOfClass(), "PlanarLine") == 0)
       {
         copiedFigure    = mitk::PlanarLine::New();
       }
       if(strcmp((*it1)->GetNameOfClass(), "PlanarPolygon") == 0)
       {
         copiedFigure    = mitk::PlanarPolygon::New();
       }
       if(strcmp((*it1)->GetNameOfClass(), "PlanarSubdivisionPolygon") == 0)
       {
         copiedFigure    = mitk::PlanarSubdivisionPolygon::New();
       }
       if(strcmp((*it1)->GetNameOfClass(), "PlanarCross") == 0)
       {
         copiedFigure    = mitk::PlanarCross::New();
       }
       if(strcmp((*it1)->GetNameOfClass(), "PlanarRectangle") == 0)
       {
         copiedFigure    = mitk::PlanarRectangle::New();
       }
       if(strcmp((*it1)->GetNameOfClass(), "PlanarFourPointAngle") == 0)
       {
         copiedFigure    = mitk::PlanarFourPointAngle::New();
       }
 
       copiedFigure->DeepCopy((*it1));
       copiedPlanarFigures.push_back(copiedFigure.GetPointer());
     }
     return copiedPlanarFigures;
   }
 
 
   static void VerifyPlanarFigures( PlanarFigureList &planarFigures1, PlanarFigureList &planarFigures2 )
   {
     PlanarFigureList::iterator it1, it2;
 
     for ( it1 = planarFigures1.begin(); it1 != planarFigures1.end(); ++it1 )
     {
       bool planarFigureFound = false;
       for ( it2 = planarFigures2.begin(); it2 != planarFigures2.end(); ++it2 )
       {
         // Compare PlanarFigures (returns false if different types)
         if ( ComparePlanarFigures( *it1, *it2 ) )
         {
           planarFigureFound = true;
         }
       }
 
       // 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" );
     }
   }
 
   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;
     }
 
     // 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());
 
     // Test Geometry transform parameters
-    typedef mitk::AffineGeometryFrame3D::TransformType TransformType;
+    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
   PlanarFigureIOTestClass::PlanarFigureList copiedPlanarFigures =
       PlanarFigureIOTestClass::CreateDeepCopiedPlanarFigures(originalPlanarFigures);
 
   PlanarFigureIOTestClass::VerifyPlanarFigures(originalPlanarFigures, copiedPlanarFigures );
 
   // 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/Qmitk/QmitkDataStorageTreeModel.cpp b/Modules/Qmitk/QmitkDataStorageTreeModel.cpp
index e2508a994a..1e64846e19 100644
--- a/Modules/Qmitk/QmitkDataStorageTreeModel.cpp
+++ b/Modules/Qmitk/QmitkDataStorageTreeModel.cpp
@@ -1,919 +1,919 @@
 /*===================================================================
 
 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 <mitkStringProperty.h>
 #include <mitkNodePredicateFirstLevel.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateData.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkProperties.h>
 #include <mitkRenderingManager.h>
 
 #include "QmitkDataStorageTreeModel.h"
 #include "QmitkNodeDescriptorManager.h"
 #include <QmitkEnums.h>
 #include <QmitkCustomVariants.h>
 
 #include <QIcon>
 #include <QMimeData>
 #include <QTextStream>
 
 #include <map>
 
 QmitkDataStorageTreeModel::QmitkDataStorageTreeModel( mitk::DataStorage* _DataStorage
                                                       , bool _PlaceNewNodesOnTop
                                                       , bool _ShowHelperObjects
                                                       , bool _ShowNodesContainingNoData
                                                       , QObject* parent )
 : QAbstractItemModel(parent)
 , m_DataStorage(0)
 , m_PlaceNewNodesOnTop(_PlaceNewNodesOnTop)
 , m_ShowHelperObjects(_ShowHelperObjects)
 , m_ShowNodesContainingNoData(_ShowNodesContainingNoData)
 , m_Root(0)
 {
   this->UpdateNodeVisibility();
   this->SetDataStorage(_DataStorage);
 }
 
 QmitkDataStorageTreeModel::~QmitkDataStorageTreeModel()
 {
   // set data storage to 0 = remove all listeners
   this->SetDataStorage(0);
   m_Root->Delete(); m_Root = 0;
 
   //Removing all observers
   for ( NodeTagMapType::iterator dataIter = m_HelperObjectObserverTags.begin(); dataIter != m_HelperObjectObserverTags.end(); ++dataIter )
   {
       (*dataIter).first->GetProperty("helper object")->RemoveObserver( (*dataIter).second );
   }
   m_HelperObjectObserverTags.clear();
 }
 
 mitk::DataNode::Pointer QmitkDataStorageTreeModel::GetNode( const QModelIndex &index ) const
 {
   return this->TreeItemFromIndex(index)->GetDataNode();
 }
 
 const mitk::DataStorage::Pointer QmitkDataStorageTreeModel::GetDataStorage() const
 {
   return m_DataStorage.GetPointer();
 }
 
 QModelIndex QmitkDataStorageTreeModel::index( int row, int column, const QModelIndex & parent ) const
 {
   TreeItem* parentItem;
 
   if (!parent.isValid())
     parentItem = m_Root;
   else
     parentItem = static_cast<TreeItem*>(parent.internalPointer());
 
   TreeItem *childItem = parentItem->GetChild(row);
   if (childItem)
     return createIndex(row, column, childItem);
   else
     return QModelIndex();
 
 
 }
 
 int QmitkDataStorageTreeModel::rowCount(const QModelIndex &parent) const
 {
   TreeItem *parentTreeItem = this->TreeItemFromIndex(parent);
   return parentTreeItem->GetChildCount();
 }
 
 
 Qt::ItemFlags QmitkDataStorageTreeModel::flags( const QModelIndex& index ) const
 {
   mitk::DataNode* dataNode = this->TreeItemFromIndex(index)->GetDataNode();
   if (index.isValid())
   {
     if(DicomPropertiesExists(*dataNode))
     {
         return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
     }
     return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable
         | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
   }else{
     return Qt::ItemIsDropEnabled;
   }
 }
 
 int QmitkDataStorageTreeModel::columnCount( const QModelIndex& /* parent = QModelIndex() */ ) const
 {
   return 1;
 }
 
 QModelIndex QmitkDataStorageTreeModel::parent(const QModelIndex &index) const
 {
   if (!index.isValid())
     return QModelIndex();
 
   TreeItem *childItem = this->TreeItemFromIndex(index);
   TreeItem *parentItem = childItem->GetParent();
 
   if (parentItem == m_Root)
     return QModelIndex();
 
   return this->createIndex(parentItem->GetIndex(), 0, parentItem);
 }
 
 QmitkDataStorageTreeModel::TreeItem* QmitkDataStorageTreeModel::TreeItemFromIndex( const QModelIndex &index ) const
 {
   if (index.isValid())
     return static_cast<TreeItem *>(index.internalPointer());
   else
     return m_Root;
 }
 Qt::DropActions QmitkDataStorageTreeModel::supportedDropActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions QmitkDataStorageTreeModel::supportedDragActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 bool QmitkDataStorageTreeModel::dropMimeData(const QMimeData *data,
                                      Qt::DropAction action, int /*row*/, int /*column*/, const QModelIndex &parent)
 {
   // Early exit, returning true, but not actually doing anything (ignoring data).
   if (action == Qt::IgnoreAction)
   {
     return true;
   }
 
   // Note, we are returning true if we handled it, and false otherwise
   bool returnValue = false;
 
   if(data->hasFormat("application/x-qabstractitemmodeldatalist"))
   {
     returnValue = true;
 
     // First we extract a Qlist of TreeItem* pointers.
     QString arg = QString(data->data("application/x-qabstractitemmodeldatalist").data());
     QStringList listOfTreeItemAddressPointers = arg.split(",");
 
     QStringList::iterator slIter;
     QList<TreeItem*> listOfItemsToDrop;
 
     for(slIter  = listOfTreeItemAddressPointers.begin();
         slIter != listOfTreeItemAddressPointers.end();
         slIter++)
     {
       long val = (*slIter).toLong();
       listOfItemsToDrop << static_cast<TreeItem *>((void*)val);
     }
 
     // Retrieve the TreeItem* where we are dropping stuff, and its parent.
     TreeItem* dropItem = this->TreeItemFromIndex(parent);
     TreeItem* parentItem = dropItem->GetParent();
 
     // If item was dropped onto empty space, we select the root node
     if(dropItem == m_Root)
     {
       parentItem = m_Root;
     }
 
     // Dragging and Dropping is only allowed within the same parent, so use the first item in list to validate.
     // (otherwise, you could have a derived image such as a segmentation, and assign it to another image).
     // NOTE: We are assuming the input list is valid... i.e. when it was dragged, all the items had the same parent.
 
     if(listOfItemsToDrop[0] != dropItem && listOfItemsToDrop[0]->GetParent() == parentItem)
     {
       // Retrieve the index of where we are dropping stuff.
       QModelIndex dropItemModelIndex = this->IndexFromTreeItem(dropItem);
       QModelIndex parentModelIndex = this->IndexFromTreeItem(parentItem);
 
       // Iterate through the list of TreeItem (which may be at non-consecutive indexes).
       QList<TreeItem*>::iterator diIter;
       for (diIter  = listOfItemsToDrop.begin();
            diIter != listOfItemsToDrop.end();
            diIter++)
       {
         // Here we assume that as you remove items, one at a time, that GetIndex() will be valid.
         this->beginRemoveRows(parentModelIndex, (*diIter)->GetIndex(), (*diIter)->GetIndex());
         parentItem->RemoveChild(*diIter);
         this->endRemoveRows();
       }
 
       // Select the target index position, or put it at the end of the list.
       int dropIndex = dropItemModelIndex.row();
       if (dropIndex == -1)
       {
         dropIndex = parentItem->GetChildCount();
       }
 
       // Now insert items again at the drop item position
       this->beginInsertRows(parentModelIndex, dropIndex, dropIndex + listOfItemsToDrop.size() - 1);
 
       for (diIter  = listOfItemsToDrop.begin();
            diIter != listOfItemsToDrop.end();
            diIter++)
       {
         parentItem->InsertChild( (*diIter), dropIndex );
         dropIndex++;
       }
       this->endInsertRows();
 
       // Change Layers to match.
       this->AdjustLayerProperty();
     }
   }
   else if(data->hasFormat("application/x-mitk-datanodes"))
   {
     returnValue = true;
 
     QString arg = QString(data->data("application/x-mitk-datanodes").data());
     QStringList listOfDataNodeAddressPointers = arg.split(",");
     int numberOfNodesDropped = 0;
 
     QStringList::iterator slIter;
     for (slIter = listOfDataNodeAddressPointers.begin();
          slIter != listOfDataNodeAddressPointers.end();
          slIter++)
     {
       long val = (*slIter).toLong();
       mitk::DataNode* node = static_cast<mitk::DataNode *>((void*)val);
 
       if(node && m_DataStorage.IsNotNull() && !m_DataStorage->Exists(node))
       {
           m_DataStorage->Add( node );
           mitk::BaseData::Pointer basedata = node->GetData();
 
           if (basedata.IsNotNull())
           {
             mitk::RenderingManager::GetInstance()->InitializeViews(
-              basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+              basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
 
             numberOfNodesDropped++;
           }
       }
     }
     // Only do a rendering update, if we actually dropped anything.
     if (numberOfNodesDropped > 0)
     {
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 
   return returnValue;
 }
 
 QStringList QmitkDataStorageTreeModel::mimeTypes() const
 {
     QStringList types = QAbstractItemModel::mimeTypes();
     types << "application/x-qabstractitemmodeldatalist";
     types << "application/x-mitk-datanodes";
     return types;
 }
 
 QMimeData * QmitkDataStorageTreeModel::mimeData(const QModelIndexList & indexes) const{
 
   QMimeData * ret = new QMimeData;
 
   QString treeItemAddresses("");
   QString dataNodeAddresses("");
 
   for (int i = 0; i < indexes.size(); i++)
   {
     TreeItem* treeItem = static_cast<TreeItem*>(indexes.at(i).internalPointer());
     long treeItemAddress = reinterpret_cast<long>(treeItem);
     long dataNodeAddress = reinterpret_cast<long>(treeItem->GetDataNode().GetPointer());
     QTextStream(&treeItemAddresses) << treeItemAddress;
     QTextStream(&dataNodeAddresses) << dataNodeAddress;
 
     if (i != indexes.size() - 1)
     {
       QTextStream(&treeItemAddresses) << ",";
       QTextStream(&dataNodeAddresses) << ",";
     }
   }
 
   ret->setData("application/x-qabstractitemmodeldatalist", QByteArray(treeItemAddresses.toAscii()));
   ret->setData("application/x-mitk-datanodes", QByteArray(dataNodeAddresses.toAscii()));
 
   return ret;
 }
 
 QVariant QmitkDataStorageTreeModel::data( const QModelIndex & index, int role ) const
 {
   mitk::DataNode* dataNode = this->TreeItemFromIndex(index)->GetDataNode();
 
   // get name of treeItem (may also be edited)
   QString nodeName;
   if(DicomPropertiesExists(*dataNode))
   {
     mitk::BaseProperty* seriesDescription = (dataNode->GetProperty("dicom.series.SeriesDescription"));
     mitk::BaseProperty* studyDescription = (dataNode->GetProperty("dicom.study.StudyDescription"));
     mitk::BaseProperty* patientsName = (dataNode->GetProperty("dicom.patient.PatientsName"));
 
     nodeName.append(patientsName->GetValueAsString().c_str()).append("\n");
     nodeName.append(studyDescription->GetValueAsString().c_str()).append("\n");
     nodeName.append(seriesDescription->GetValueAsString().c_str());
   }else{
       nodeName = QString::fromStdString(dataNode->GetName());
   }
   if(nodeName.isEmpty())
   {
     nodeName = "unnamed";
   }
 
   if (role == Qt::DisplayRole)
     return nodeName;
   else if(role == Qt::ToolTipRole)
     return nodeName;
   else if(role == Qt::DecorationRole)
   {
     QmitkNodeDescriptor* nodeDescriptor
       = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon();
   }
   else if(role == Qt::CheckStateRole)
   {
     return dataNode->IsVisible(0);
   }
   else if(role == QmitkDataNodeRole)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
   else if(role == QmitkDataNodeRawPointerRole)
   {
     return QVariant::fromValue<mitk::DataNode*>(dataNode);
   }
 
   return QVariant();
 }
 
 bool QmitkDataStorageTreeModel::DicomPropertiesExists(const mitk::DataNode& node) const
 {
     bool propertiesExists = false;
     mitk::BaseProperty* seriesDescription = (node.GetProperty("dicom.series.SeriesDescription"));
     mitk::BaseProperty* studyDescription = (node.GetProperty("dicom.study.StudyDescription"));
     mitk::BaseProperty* patientsName = (node.GetProperty("dicom.patient.PatientsName"));
 
     if(patientsName!=NULL && studyDescription!=NULL && seriesDescription!=NULL)
     {
         if((!patientsName->GetValueAsString().empty())&&
             (!studyDescription->GetValueAsString().empty())&&
             (!seriesDescription->GetValueAsString().empty()))
         {
             propertiesExists = true;
         }
     }
     return propertiesExists;
 }
 
 
 QVariant QmitkDataStorageTreeModel::headerData(int /*section*/,
                                  Qt::Orientation orientation,
                                  int role) const
 {
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole && m_Root)
      return QString::fromStdString(m_Root->GetDataNode()->GetName());
 
    return QVariant();
 }
 
 void QmitkDataStorageTreeModel::SetDataStorage( mitk::DataStorage* _DataStorage )
 {
   if(m_DataStorage != _DataStorage) // dont take the same again
   {
     if(m_DataStorage.IsNotNull())
     {
       // remove Listener for the data storage itself
       m_DataStorage.ObjectDelete.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const itk::Object*>( this, &QmitkDataStorageTreeModel::SetDataStorageDeleted ) );
 
       // remove listeners for the nodes
       m_DataStorage->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::AddNode ) );
 
       m_DataStorage->ChangedNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::SetNodeModified ) );
 
       m_DataStorage->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::RemoveNode ) );
 
     }
 
     // take over the new data storage
     m_DataStorage = _DataStorage;
 
     // delete the old root (if necessary, create new)
     if(m_Root)
       m_Root->Delete();
     mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
     rootDataNode->SetName("Data Manager");
     m_Root = new TreeItem(rootDataNode, 0);
     this->reset();
 
     if(m_DataStorage.IsNotNull())
     {
       // add Listener for the data storage itself
       m_DataStorage.ObjectDelete.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const itk::Object*>( this, &QmitkDataStorageTreeModel::SetDataStorageDeleted ) );
 
       // add listeners for the nodes
       m_DataStorage->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::AddNode ) );
 
       m_DataStorage->ChangedNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::SetNodeModified ) );
 
       m_DataStorage->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
         , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::RemoveNode ) );
 
       mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = m_DataStorage->GetSubset(m_Predicate);
 
       // finally add all nodes to the model
       this->Update();
     }
   }
 }
 
 void QmitkDataStorageTreeModel::SetDataStorageDeleted( const itk::Object* /*_DataStorage*/ )
 {
   this->SetDataStorage(0);
 }
 
 void QmitkDataStorageTreeModel::AddNodeInternal(const mitk::DataNode *node)
 {
     if(node == 0
       || m_DataStorage.IsNull()
       || !m_DataStorage->Exists(node)
       || !m_Predicate->CheckNode(node)
       || m_Root->Find(node) != 0)
       return;
 
     // find out if we have a root node
     TreeItem* parentTreeItem = m_Root;
     QModelIndex index;
     mitk::DataNode* parentDataNode = this->GetParentNode(node);
 
     if(parentDataNode) // no top level data node
     {
       parentTreeItem = m_Root->Find(parentDataNode); // find the corresponding tree item
       if(!parentTreeItem)
       {
         this->AddNode(parentDataNode);
         parentTreeItem = m_Root->Find(parentDataNode);
         if(!parentTreeItem)
           return;
       }
 
       // get the index of this parent with the help of the grand parent
       index = this->createIndex(parentTreeItem->GetIndex(), 0, parentTreeItem);
     }
 
     // add node
     if(m_PlaceNewNodesOnTop)
     {
       // emit beginInsertRows event
       beginInsertRows(index, 0, 0);
       parentTreeItem->InsertChild(new TreeItem(
           const_cast<mitk::DataNode*>(node)), 0);
     }
     else
     {
       beginInsertRows(index, parentTreeItem->GetChildCount()
                       , parentTreeItem->GetChildCount());
       new TreeItem(const_cast<mitk::DataNode*>(node), parentTreeItem);
     }
 
     // emit endInsertRows event
     endInsertRows();
 
     this->AdjustLayerProperty();
 }
 
 void QmitkDataStorageTreeModel::AddNode( const mitk::DataNode* node )
 {
     if(node == 0
       || m_DataStorage.IsNull()
       || !m_DataStorage->Exists(node)
       || m_Root->Find(node) != 0)
       return;
 
     bool isHelperObject (false);
     NodeTagMapType::iterator searchIter = m_HelperObjectObserverTags.find( const_cast<mitk::DataNode*>(node) );
     if (node->GetBoolProperty("helper object", isHelperObject) && searchIter == m_HelperObjectObserverTags.end()) {
         itk::SimpleMemberCommand<QmitkDataStorageTreeModel>::Pointer command = itk::SimpleMemberCommand<QmitkDataStorageTreeModel>::New();
         command->SetCallbackFunction(this, &QmitkDataStorageTreeModel::UpdateNodeVisibility);
         m_HelperObjectObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( const_cast<mitk::DataNode*>(node), node->GetProperty("helper object")->AddObserver( itk::ModifiedEvent(), command ) ) );
     }
 
     if (m_Predicate->CheckNode(node))
       this->AddNodeInternal(node);
 }
 
 
 void QmitkDataStorageTreeModel::SetPlaceNewNodesOnTop(bool _PlaceNewNodesOnTop)
 {
   m_PlaceNewNodesOnTop = _PlaceNewNodesOnTop;
 }
 
 void QmitkDataStorageTreeModel::RemoveNodeInternal( const mitk::DataNode* node )
 {
     if(!m_Root) return;
 
     TreeItem* treeItem = m_Root->Find(node);
     if(!treeItem)
       return; // return because there is no treeitem containing this node
 
     TreeItem* parentTreeItem = treeItem->GetParent();
     QModelIndex parentIndex = this->IndexFromTreeItem(parentTreeItem);
 
     // emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
     this->beginRemoveRows(parentIndex, treeItem->GetIndex(), treeItem->GetIndex());
 
     // remove node
     std::vector<TreeItem*> children = treeItem->GetChildren();
     delete treeItem;
 
     // emit endRemoveRows event
     endRemoveRows();
 
     // move all children of deleted node into its parent
     for ( std::vector<TreeItem*>::iterator it = children.begin()
       ; it != children.end(); it++)
     {
       // emit beginInsertRows event
       beginInsertRows(parentIndex, parentTreeItem->GetChildCount(), parentTreeItem->GetChildCount());
 
       // add nodes again
       parentTreeItem->AddChild(*it);
 
       // emit endInsertRows event
       endInsertRows();
     }
 
     this->AdjustLayerProperty();
 }
 
 void QmitkDataStorageTreeModel::RemoveNode( const mitk::DataNode* node )
 {
     if (node == 0)
         return;
 
     //Removing Observer
     bool isHelperObject (false);
     NodeTagMapType::iterator searchIter = m_HelperObjectObserverTags.find( const_cast<mitk::DataNode*>(node) );
     if (node->GetBoolProperty("helper object", isHelperObject) && searchIter != m_HelperObjectObserverTags.end()) {
         (*searchIter).first->GetProperty("helper object")->RemoveObserver( (*searchIter).second );
         m_HelperObjectObserverTags.erase(const_cast<mitk::DataNode*>(node));
     }
 
     this->RemoveNodeInternal(node);
 }
 
 void QmitkDataStorageTreeModel::SetNodeModified( const mitk::DataNode* node )
 {
   TreeItem* treeItem = m_Root->Find(node);
   if(!treeItem)
   {
     // check if the node still fits the predicates
     if( m_Predicate->CheckNode( node ) )
     {
       this->UpdateNodeVisibility();
     }
   }
   else
   {
     TreeItem* parentTreeItem = treeItem->GetParent();
     // as the root node should not be removed one should always have a parent item
     if(!parentTreeItem)
       return;
     QModelIndex index = this->createIndex(treeItem->GetIndex(), 0, treeItem);
 
     // now emit the dataChanged signal
     emit dataChanged(index, index);
   }
 }
 
 mitk::DataNode* QmitkDataStorageTreeModel::GetParentNode( const mitk::DataNode* node ) const
 {
   mitk::DataNode* dataNode = 0;
 
   mitk::DataStorage::SetOfObjects::ConstPointer _Sources = m_DataStorage->GetSources(node);
 
   if(_Sources->Size() > 0)
     dataNode = _Sources->front();
 
   return dataNode;
 }
 
 bool QmitkDataStorageTreeModel::setData( const QModelIndex &index, const QVariant &value, int role )
 {
   mitk::DataNode* dataNode = this->TreeItemFromIndex(index)->GetDataNode();
   if(!dataNode)
     return false;
 
   if(role == Qt::EditRole && !value.toString().isEmpty())
   {
     dataNode->SetStringProperty("name", value.toString().toStdString().c_str());
   }
   else if(role == Qt::CheckStateRole)
   {
     // Please note: value.toInt() returns 2, independentely from the actual checkstate of the index element.
   // Therefore the checkstate is being estimated again here.
 
   QVariant qcheckstate = index.data(Qt::CheckStateRole);
   int checkstate = qcheckstate.toInt();
     bool isVisible = bool(checkstate);
   dataNode->SetVisibility(!isVisible);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   // inform listeners about changes
   emit dataChanged(index, index);
   return true;
 }
 
 bool QmitkDataStorageTreeModel::setHeaderData( int /*section*/, Qt::Orientation /*orientation*/, const QVariant& /* value */, int /*role = Qt::EditRole*/ )
 {
   return false;
 }
 
 void QmitkDataStorageTreeModel::AdjustLayerProperty()
 {
   /// transform the tree into an array and set the layer property descending
   std::vector<TreeItem*> vec;
   this->TreeToVector(m_Root, vec);
 
   int i = vec.size()-1;
   for(std::vector<TreeItem*>::const_iterator it = vec.begin(); it != vec.end(); ++it)
   {
     mitk::DataNode::Pointer dataNode = (*it)->GetDataNode();
     bool fixedLayer = false;
 
     if (!(dataNode->GetBoolProperty("fixedLayer", fixedLayer) && fixedLayer))
       dataNode->SetIntProperty("layer", i);
 
     --i;
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataStorageTreeModel::TreeToVector(TreeItem* parent, std::vector<TreeItem*>& vec) const
 {
   TreeItem* current;
   for(int i = 0; i<parent->GetChildCount(); ++i)
   {
     current = parent->GetChild(i);
     this->TreeToVector(current, vec);
     vec.push_back(current);
   }
 }
 
 QModelIndex QmitkDataStorageTreeModel::IndexFromTreeItem( TreeItem* item ) const
 {
   if(item == m_Root)
     return QModelIndex();
   else
     return this->createIndex(item->GetIndex(), 0, item);
 }
 
 QList<mitk::DataNode::Pointer> QmitkDataStorageTreeModel::GetNodeSet() const
 {
   QList<mitk::DataNode::Pointer> res;
   if(m_Root)
     this->TreeToNodeSet(m_Root, res);
 
   return res;
 }
 
 void QmitkDataStorageTreeModel::TreeToNodeSet( TreeItem* parent, QList<mitk::DataNode::Pointer>& vec ) const
 {
   TreeItem* current;
   for(int i = 0; i<parent->GetChildCount(); ++i)
   {
     current = parent->GetChild(i);
     vec.push_back(current->GetDataNode());
     this->TreeToNodeSet(current, vec);
   }
 }
 
 QModelIndex QmitkDataStorageTreeModel::GetIndex( const mitk::DataNode* node ) const
 {
   if(m_Root)
   {
     TreeItem* item = m_Root->Find(node);
     if(item)
       return this->IndexFromTreeItem(item);
   }
   return QModelIndex();
 }
 
 QmitkDataStorageTreeModel::TreeItem::TreeItem( mitk::DataNode* _DataNode, TreeItem* _Parent )
 : m_Parent(_Parent)
 , m_DataNode(_DataNode)
 {
   if(m_Parent)
     m_Parent->AddChild(this);
 }
 
 QmitkDataStorageTreeModel::TreeItem::~TreeItem()
 {
   if(m_Parent)
     m_Parent->RemoveChild(this);
 }
 
 void QmitkDataStorageTreeModel::TreeItem::Delete()
 {
   while(m_Children.size() > 0)
     delete m_Children.back();
 
   delete this;
 }
 
 QmitkDataStorageTreeModel::TreeItem* QmitkDataStorageTreeModel::TreeItem::Find( const mitk::DataNode* _DataNode ) const
 {
   QmitkDataStorageTreeModel::TreeItem* item = 0;
   if(_DataNode)
   {
     if(m_DataNode == _DataNode)
       item = const_cast<TreeItem*>(this);
     else
     {
       for(std::vector<TreeItem*>::const_iterator it = m_Children.begin(); it != m_Children.end(); ++it)
       {
         if(item)
           break;
         item = (*it)->Find(_DataNode);
       }
     }
   }
   return item;
 }
 
 int QmitkDataStorageTreeModel::TreeItem::IndexOfChild( const TreeItem* item ) const
 {
   std::vector<TreeItem*>::const_iterator it = std::find(m_Children.begin(), m_Children.end(), item);
   return it != m_Children.end() ? std::distance(m_Children.begin(), it): -1;
 }
 
 QmitkDataStorageTreeModel::TreeItem* QmitkDataStorageTreeModel::TreeItem::GetChild( int index ) const
 {
   return (m_Children.size() > 0 && index >= 0 && index < (int)m_Children.size())? m_Children.at(index): 0;
 }
 
 void QmitkDataStorageTreeModel::TreeItem::AddChild( TreeItem* item )
 {
   this->InsertChild(item);
 }
 
 void QmitkDataStorageTreeModel::TreeItem::RemoveChild( TreeItem* item )
 {
   std::vector<TreeItem*>::iterator it = std::find(m_Children.begin(), m_Children.end(), item);
   if(it != m_Children.end())
   {
     m_Children.erase(it);
     item->SetParent(0);
   }
 }
 
 int QmitkDataStorageTreeModel::TreeItem::GetChildCount() const
 {
   return m_Children.size();
 }
 
 int QmitkDataStorageTreeModel::TreeItem::GetIndex() const
 {
   if (m_Parent)
     return m_Parent->IndexOfChild(this);
 
   return 0;
 }
 
 QmitkDataStorageTreeModel::TreeItem* QmitkDataStorageTreeModel::TreeItem::GetParent() const
 {
   return m_Parent;
 }
 
 mitk::DataNode::Pointer QmitkDataStorageTreeModel::TreeItem::GetDataNode() const
 {
   return m_DataNode;
 }
 
 void QmitkDataStorageTreeModel::TreeItem::InsertChild( TreeItem* item, int index )
 {
   std::vector<TreeItem*>::iterator it = std::find(m_Children.begin(), m_Children.end(), item);
   if(it == m_Children.end())
   {
     if(m_Children.size() > 0 && index >= 0 && index < (int)m_Children.size())
     {
       it = m_Children.begin();
       std::advance(it, index);
       m_Children.insert(it, item);
     }
     else
       m_Children.push_back(item);
 
     // add parent if necessary
     if(item->GetParent() != this)
       item->SetParent(this);
   }
 }
 
 std::vector<QmitkDataStorageTreeModel::TreeItem*> QmitkDataStorageTreeModel::TreeItem::GetChildren() const
 {
   return m_Children;
 }
 
 void QmitkDataStorageTreeModel::TreeItem::SetParent( TreeItem* _Parent )
 {
   m_Parent = _Parent;
   if(m_Parent)
     m_Parent->AddChild(this);
 }
 
 void QmitkDataStorageTreeModel::SetShowHelperObjects(bool _ShowHelperObjects)
 {
   m_ShowHelperObjects = _ShowHelperObjects;
   this->UpdateNodeVisibility();
 }
 
 void QmitkDataStorageTreeModel::SetShowNodesContainingNoData(bool _ShowNodesContainingNoData)
 {
   m_ShowNodesContainingNoData = _ShowNodesContainingNoData;
   this->UpdateNodeVisibility();
 }
 
 void QmitkDataStorageTreeModel::UpdateNodeVisibility()
 {
   mitk::NodePredicateData::Pointer dataIsNull = mitk::NodePredicateData::New(0);
   mitk::NodePredicateNot::Pointer dataIsNotNull = mitk::NodePredicateNot::New(dataIsNull);// Show only nodes that really contain dat
 
   if (m_ShowHelperObjects)
   {
     if (m_ShowNodesContainingNoData)
     {
       // Show every node
       m_Predicate = mitk::NodePredicateOr::New(dataIsNull, dataIsNotNull);
     }
     else
     {
       // Show helper objects but not nodes containing no data
       m_Predicate = dataIsNotNull;
     }
   }
   else
   {
     mitk::NodePredicateProperty::Pointer isHelperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true));
     mitk::NodePredicateNot::Pointer isNotHelperObject = mitk::NodePredicateNot::New(isHelperObject);// Show only nodes that are not helper objects
     if (m_ShowNodesContainingNoData)
     {
       // Don't show helper objects but nodes containing no data
       m_Predicate = isNotHelperObject;
     }
     else
     {
       // Don't show helper objects and nodes containing no data
       m_Predicate = mitk::NodePredicateAnd::New(isNotHelperObject, dataIsNotNull);
     }
   }
   this->Update();
 }
 
 void QmitkDataStorageTreeModel::Update()
 {
   if (m_DataStorage.IsNotNull())
   {
     this->reset();
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = m_DataStorage->GetSubset(m_Predicate);
 
     for(mitk::DataStorage::SetOfObjects::const_iterator it=_NodeSet->begin(); it!=_NodeSet->end(); it++)
     {
       // save node
       this->AddNodeInternal(*it);
     }
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NotNodeSet = m_DataStorage->GetSubset(mitk::NodePredicateNot::New(m_Predicate));
 
     for(mitk::DataStorage::SetOfObjects::const_iterator it=_NotNodeSet->begin(); it!=_NotNodeSet->end(); it++)
     {
       // remove node
       this->RemoveNodeInternal(*it);
     }
 
   }
 }
 
diff --git a/Modules/Qmitk/QmitkStdMultiWidget.cpp b/Modules/Qmitk/QmitkStdMultiWidget.cpp
index a24814d297..6f2560bc90 100644
--- a/Modules/Qmitk/QmitkStdMultiWidget.cpp
+++ b/Modules/Qmitk/QmitkStdMultiWidget.cpp
@@ -1,2263 +1,2263 @@
 /*===================================================================
 
 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 "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)
 : 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);
   mitkWidget1->setMaximumSize(2000,2000);
   mitkWidget1->SetLayoutIndex( AXIAL );
   mitkWidgetLayout1->addWidget(mitkWidget1);
 
   //Create RenderWindows 2
   mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, "stdmulti.widget2", NULL, m_RenderingManager);
   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);
   mitkWidget3->setMaximumSize(2000,2000);
   mitkWidget3->SetLayoutIndex( CORONAL );
   mitkWidgetLayout3->addWidget(mitkWidget3);
 
   //Create RenderWindows 4
   mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, "stdmulti.widget4", NULL, m_RenderingManager);
   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->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->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->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->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);
     }
   }
 }
 
 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;
 
   // ... of widget 1
   m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   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();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   m_PlaneNode2 =( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   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();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   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();
   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())
   {
     mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
     mitk::NodePredicateNot::Pointer pred2
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(true)));
 
     mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetSubset(pred);
     mitk::DataStorage::SetOfObjects::ConstPointer rs2 = m_DataStorage->GetSubset(pred2);
     // calculate bounding geometry of these nodes
-    mitk::TimeSlicedGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");
+    mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");
 
     m_RenderingManager->InitializeViews(bounds);
     //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;
   }
 }
 
diff --git a/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp b/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp
index a1fa417762..eb01aab444 100644
--- a/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp
+++ b/Modules/QmitkExt/QmitkBoundingObjectWidget.cpp
@@ -1,468 +1,468 @@
 /*===================================================================
 
 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 "QmitkBoundingObjectWidget.h"
 
 #include <mitkCone.h>
 #include <mitkCylinder.h>
 #include <mitkCuboid.h>
 #include <mitkEllipsoid.h>
 #include <mitkAffineInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkLine.h>
 
 #include <QPushButton>
 #include <QCheckBox>
 #include <QBoxLayout>
 #include <QStringList>
 #include <QInputDialog>
 
 #include "btnCube.xpm"
 #include "btnCylinder.xpm"
 #include "btnEllipsoid.xpm"
 #include "btnPyramid.xpm"
 
 
 QmitkBoundingObjectWidget::QmitkBoundingObjectWidget (QWidget* parent, Qt::WindowFlags f ):QWidget( parent, f ),
 m_DataStorage(NULL),
 m_lastSelectedItem(NULL),
 m_lastAffineObserver(NULL),
 m_ItemNodeMap(),
 m_BoundingObjectCounter(1)
 {
 
   QBoxLayout* mainLayout = new QVBoxLayout(this);
 
   QHBoxLayout* buttonLayout = new QHBoxLayout();
 
   QStringList boList;
   boList << tr("add") << tr("cube") << tr("cone") << tr("ellipse") << tr("cylinder");
   m_addComboBox = new QComboBox();
   m_addComboBox->addItems(boList);
   m_addComboBox->setItemIcon(1, QIcon(btnCube_xpm));
   m_addComboBox->setItemIcon(2, QIcon(btnPyramid_xpm));
   m_addComboBox->setItemIcon(3, QIcon(btnEllipsoid_xpm));
   m_addComboBox->setItemIcon(4, QIcon(btnCylinder_xpm));
 
   buttonLayout->addWidget(m_addComboBox);
 
   m_DelButton = new QPushButton("del");
   buttonLayout->addWidget(m_DelButton);
 
 
   m_SaveButton = new QPushButton("save");
   buttonLayout->addWidget(m_SaveButton);
   m_SaveButton->setEnabled(false);
 
   m_LoadButton = new QPushButton("load");
   buttonLayout->addWidget(m_LoadButton);
   m_LoadButton->setEnabled(false);
 
   m_TreeWidget = new QTreeWidget(this);
   m_TreeWidget->setColumnCount(3);
   QStringList sList;
   sList << tr("name") << tr("inverted") << tr("visible");
   m_TreeWidget->setHeaderLabels(sList);
   m_TreeWidget->setColumnWidth(0, 250);
   m_TreeWidget->setColumnWidth(1, 50);
   m_TreeWidget->setColumnWidth(2, 50);
   m_TreeWidget->setAutoScroll(true);
   m_TreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
 
   mainLayout->addWidget(m_TreeWidget);
   mainLayout->addLayout(buttonLayout);
 
   connect( m_addComboBox , SIGNAL(currentIndexChanged(int)), this, SLOT(CreateBoundingObject(int)) );
   connect( m_TreeWidget, SIGNAL(itemSelectionChanged()), this, SLOT(SelectionChanged()) );
   /*connect( m_SaveButton, SIGNAL(clicked()), this, SLOT(OnSaveButtonClicked()) );
   connect( m_LoadButton, SIGNAL(clicked()), this, SLOT(OnLoadButtonClicked()) );*/
   connect( m_DelButton, SIGNAL(clicked()), this, SLOT(OnDelButtonClicked()) );
 
   connect(m_TreeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(OnItemDoubleClicked(QTreeWidgetItem*, int)) );
   connect(m_TreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(OnItemDataChanged(QTreeWidgetItem*, int)) );
 
 }
 
 QmitkBoundingObjectWidget::~QmitkBoundingObjectWidget()
 {
 
 }
 
 void QmitkBoundingObjectWidget::setEnabled(bool flag)
 {
   ItemNodeMapType::iterator it = m_ItemNodeMap.begin();
   while( it != m_ItemNodeMap.end())
   {
     mitk::DataNode* node = it->second;
     QTreeWidgetItem* item = it->first;
 
     if (flag)
       node->SetVisibility(item->checkState(2));
     else
       node->SetVisibility(flag);
     ++it;
   }
 
   QWidget::setEnabled(flag);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkBoundingObjectWidget::SelectionChanged()
 {
 
   QList<QTreeWidgetItem*> selectedItems = m_TreeWidget->selectedItems();
   if (selectedItems.size() < 1)
     return;
 
   QTreeWidgetItem* selectedItem = selectedItems.first();
 
   if (selectedItem == m_lastSelectedItem)
     return;
 
   if (m_lastSelectedItem != NULL)
   {
     m_TreeWidget->closePersistentEditor(m_lastSelectedItem, 0);
 
     ItemNodeMapType::iterator it = m_ItemNodeMap.find(m_lastSelectedItem);
 
     if (it != m_ItemNodeMap.end())
     {
       mitk::DataNode* last_node = it->second;
 
       //remove observer
       last_node->RemoveObserver(m_lastAffineObserver);
 
       //get and remove interactor
       mitk::AffineInteractor::Pointer last_interactor = dynamic_cast<mitk::AffineInteractor*> (last_node->GetInteractor());
       if (last_interactor)
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(last_interactor);
     }
   }
 
   ItemNodeMapType::iterator it = m_ItemNodeMap.find(selectedItem);
   if (it == m_ItemNodeMap.end())
     return;
 
   mitk::DataNode* new_node = it->second;
 
   mitk::AffineInteractor::Pointer new_interactor = mitk::AffineInteractor::New("AffineInteractions ctrl-drag", new_node);
   new_node->SetInteractor(new_interactor);
 
   mitk::GlobalInteraction::GetInstance()->AddInteractor(new_interactor);
 
   //create observer for node
   itk::ReceptorMemberCommand<QmitkBoundingObjectWidget>::Pointer command = itk::ReceptorMemberCommand<QmitkBoundingObjectWidget>::New();
   command->SetCallbackFunction(this, &QmitkBoundingObjectWidget::OnBoundingObjectModified);
   m_lastAffineObserver = new_node->AddObserver(mitk::AffineInteractionEvent(), command);
 
   m_lastSelectedItem = selectedItem;
 }
 
 void QmitkBoundingObjectWidget::AddItem(mitk::DataNode* node)
 {
   mitk::BoundingObject* boundingObject;
 
   boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
 
   std::string name;
   node->GetStringProperty("name", name);
 
   if (boundingObject)
   {
     QTreeWidgetItem* item = new QTreeWidgetItem();
     item->setData(0, Qt::EditRole,  QString::fromLocal8Bit(name.c_str()));
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
 
     //checkbox for positive flag
     item->setData(1, Qt::CheckStateRole, tr(""));
     item->setCheckState(1, Qt::Unchecked);
 
     //checkbox for visibleflag
     item->setData(2, Qt::CheckStateRole, tr(""));
     item->setCheckState(2, Qt::Checked);
 
     m_TreeWidget->addTopLevelItem(item);
 
     m_ItemNodeMap.insert(std::make_pair(item, node));
 
     m_TreeWidget->selectAll();
     QList<QTreeWidgetItem*> items = m_TreeWidget->selectedItems();
     for( int i = 0; i<items.size(); i++)
     {
       m_TreeWidget->setItemSelected(items.at(i), false);
     }
 
     m_TreeWidget->setItemSelected(item, true);
 
 
   }
   else
     MITK_ERROR << name << " is not a bounding object or does not exist in data storage" << endl;
 }
 
 void QmitkBoundingObjectWidget::OnItemDoubleClicked(QTreeWidgetItem* item, int col)
 {
   if (col == 0)
   {
     m_TreeWidget->openPersistentEditor(item, col);
   }
 }
 
 void QmitkBoundingObjectWidget::OnItemDataChanged(QTreeWidgetItem *item, int col)
 {
   if (m_ItemNodeMap.size() < 1)
     return;
 
   ItemNodeMapType::iterator it = m_ItemNodeMap.find(item);
   if (it == m_ItemNodeMap.end())
     return;
 
   mitk::DataNode* node = it->second;
 
   //name
   if (col == 0)
   {
     m_TreeWidget->closePersistentEditor(item, col);
     node->SetName(item->text(0).toLocal8Bit().data());
   }
   //positive
   else if (col == 1)
   {
     mitk::BoundingObject* boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
       boundingObject->SetPositive(!(item->checkState(1)));
     emit BoundingObjectsChanged();
   }
   //visible
   else if (col == 2)
   {
     node->SetVisibility(item->checkState(2));
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
 
 }
 
 void QmitkBoundingObjectWidget::RemoveItem()
 {
   //selection mode is set to single selection, so there should not be more than one selected item
   QList <QTreeWidgetItem*> selectedItems = m_TreeWidget->selectedItems();
   QTreeWidgetItem* item = selectedItems.first();
   QString str = item->text(0);
 
   ItemNodeMapType::iterator it = m_ItemNodeMap.find(item);
 
   if (it == m_ItemNodeMap.end())
     return;
 
   mitk::DataNode* node = it->second;
   mitk::BoundingObject* boundingObject;
 
   if (node)
   {
     boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
     {
       //delete item;
       m_TreeWidget->takeTopLevelItem(m_TreeWidget->indexOfTopLevelItem(item));
       m_ItemNodeMap.erase(m_ItemNodeMap.find(item));
       m_DataStorage->Remove(node);
     }
   }
 }
 
 void QmitkBoundingObjectWidget::RemoveAllItems()
 {
   ItemNodeMapType::iterator it = m_ItemNodeMap.begin();
 
   while( it != m_ItemNodeMap.end() )
   {
     m_TreeWidget->takeTopLevelItem( m_TreeWidget->indexOfTopLevelItem(it->first) );
     m_ItemNodeMap.erase(m_ItemNodeMap.find(it->first));
 
     ++it;
   }
 
   m_BoundingObjectCounter = 1;
 }
 
 
 mitk::BoundingObject::Pointer QmitkBoundingObjectWidget::GetSelectedBoundingObject()
 {
   mitk::BoundingObject* boundingObject;
   mitk::DataNode* node = this->GetSelectedBoundingObjectNode();
 
   if (node)
   {
     boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
       return boundingObject;
   }
   return NULL;
 }
 
 void QmitkBoundingObjectWidget::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 mitk::DataStorage* QmitkBoundingObjectWidget::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 //void QmitkBoundingObjectWidget::OnSaveButtonClicked()
 //{
 //
 //}
 //
 //void QmitkBoundingObjectWidget::OnLoadButtonClicked()
 //{
 //
 //}
 
 void QmitkBoundingObjectWidget::OnDelButtonClicked()
 {
   RemoveItem();
 }
 
 void QmitkBoundingObjectWidget::CreateBoundingObject(int type)
 {
 
   //get cross position
   mitk::Point3D pos;
   mitk::RenderingManager::RenderWindowVector windows =  mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
 
   //hopefully we have the renderwindows in the "normal" order
   const mitk::PlaneGeometry *plane1 =
     mitk::BaseRenderer::GetInstance(windows.at(0))->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 =
     mitk::BaseRenderer::GetInstance(windows.at(1))->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 =
     mitk::BaseRenderer::GetInstance(windows.at(2))->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ( (plane1 != NULL) && (plane2 != NULL)
     && (plane1->IntersectionLine( plane2, line )) )
   {
     if ( !((plane3 != NULL)
       && (plane3->IntersectionPoint( line, pos ))) )
     {
       return;
     }
   }
 
   if (type != 0)
   {
     mitk::BoundingObject::Pointer boundingObject;
     QString name;
     name.setNum(m_BoundingObjectCounter);
 
     switch (type-1)
     {
     case CUBOID:
       boundingObject = mitk::Cuboid::New();
       name.prepend("Cube_");
       break;
     case CONE:
       boundingObject = mitk::Cone::New();
       name.prepend("Cone_");
       break;
     case ELLIPSOID:
       boundingObject = mitk::Ellipsoid::New();
       name.prepend("Ellipse_");
       break;
     case CYLINDER:
       boundingObject = mitk::Cylinder::New();
       name.prepend("Cylinder_");
       break;
     default:
       return;
       break;
     }
     m_BoundingObjectCounter++;
     m_addComboBox->setCurrentIndex(0);
 
     // set initial size
     mitk::Vector3D size;
     size.Fill(10);
     boundingObject->GetGeometry()->SetSpacing( size );
 
     boundingObject->GetGeometry()->Translate(pos.GetVectorFromOrigin());
-    boundingObject->GetTimeSlicedGeometry()->UpdateInformation();
+    boundingObject->GetTimeGeometry()->Update();
 
     //create node
     mitk::DataNode::Pointer node  = mitk::DataNode::New();
     node->SetData( boundingObject);
     node->SetProperty("name", mitk::StringProperty::New( name.toLocal8Bit().data()));
     node->SetProperty("color", mitk::ColorProperty::New(0.0, 0.0, 1.0));
     node->SetProperty("opacity", mitk::FloatProperty::New(0.7));
     node->SetProperty("bounding object", mitk::BoolProperty::New(true));
     node->SetProperty("helper object", mitk::BoolProperty::New(true));
 
     m_DataStorage->Add(node);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     emit BoundingObjectsChanged();
 
     AddItem(node);
   }
 }
 
 mitk::DataNode::Pointer QmitkBoundingObjectWidget::GetAllBoundingObjects()
 {
   mitk::DataNode::Pointer boundingObjectGroupNode = mitk::DataNode::New();
   mitk::BoundingObjectGroup::Pointer boundingObjectGroup = mitk::BoundingObjectGroup::New();
   boundingObjectGroup->SetCSGMode(mitk::BoundingObjectGroup::Union);
 
   mitk::NodePredicateProperty::Pointer prop = mitk::NodePredicateProperty::New("bounding object", mitk::BoolProperty::New(true));
   mitk::DataStorage::SetOfObjects::ConstPointer allBO = m_DataStorage->GetSubset(prop);
 
   for (mitk::DataStorage::SetOfObjects::const_iterator it = allBO->begin(); it != allBO->end(); ++it)
   {
     mitk::DataNode::Pointer node = *it;
     mitk::BoundingObject::Pointer boundingObject = dynamic_cast<mitk::BoundingObject*> (node->GetData());
     if (boundingObject)
       boundingObjectGroup->AddBoundingObject(boundingObject);
   }
 
   boundingObjectGroupNode->SetData(boundingObjectGroup);
 
   if (boundingObjectGroup->GetCount() >0)
     return boundingObjectGroupNode;
 
   return NULL;
 }
 
 mitk::DataNode::Pointer QmitkBoundingObjectWidget::GetSelectedBoundingObjectNode()
 {
   QList <QTreeWidgetItem*> selectedItems = m_TreeWidget->selectedItems();
   if (selectedItems.size() <1)
     return NULL;
 
   QTreeWidgetItem* item = selectedItems.first();
   mitk::DataNode* node = m_ItemNodeMap.find(item)->second;
 
   return node;
 }
 
 void QmitkBoundingObjectWidget::OnBoundingObjectModified(const itk::EventObject& e)
 {
   emit BoundingObjectsChanged();
 }
diff --git a/Modules/QmitkExt/QmitkCorrespondingPointSetsModel.cpp b/Modules/QmitkExt/QmitkCorrespondingPointSetsModel.cpp
index a75adb4aad..1a54923511 100644
--- a/Modules/QmitkExt/QmitkCorrespondingPointSetsModel.cpp
+++ b/Modules/QmitkExt/QmitkCorrespondingPointSetsModel.cpp
@@ -1,740 +1,740 @@
 /*===================================================================
 
 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 "QmitkCorrespondingPointSetsModel.h"
 #include <itkCommand.h>
 #include "mitkInteractionConst.h"
 #include "mitkPointOperation.h"
 #include "mitkRenderingManager.h"
 #include <mitkEvent.h>
 #include <mitkStateEvent.h>
 #include <mitkInteractionConst.h>
 #include <mitkStepper.h>
 #include <QStringListModel>
 #include <mitkPointSetInteractor.h>
 #include <mitkGlobalInteraction.h>
 
 QmitkCorrespondingPointSetsModel::QmitkCorrespondingPointSetsModel( int t, QObject* parent )
 :QAbstractTableModel(parent),
 m_PointSetNode(NULL),
 m_ReferencePointSetNode(NULL),
 m_TimeStepper(NULL),
 m_Interactor(NULL),
 m_MultiWidget( NULL ),
 m_PointSetModifiedObserverTag(0),
 m_ReferencePointSetModifiedObserverTag(0),
 m_SelectedPointSetIndex(-1)
 {
   ;
 }
 
 Qt::ItemFlags QmitkCorrespondingPointSetsModel::flags(const QModelIndex& index) const
 {
    if (index.isValid())
        return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
    else
        return Qt::ItemIsDropEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 }
 
 Qt::DropActions QmitkCorrespondingPointSetsModel::supportedDropActions() const
 {
    return Qt::CopyAction | Qt::MoveAction;
 }
 
 bool QmitkCorrespondingPointSetsModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
   if (action == Qt::IgnoreAction)
     return true;
 
   int targetRow;
 
   if (row != -1)
     targetRow = row;
   else if (parent.isValid())
     targetRow = parent.row();
   else
     targetRow = rowCount(QModelIndex());
 
   this->MoveSelectedPoint(mitk::PointSet::PointIdentifier(targetRow));
   return true;
 }
 
 QmitkCorrespondingPointSetsModel::~QmitkCorrespondingPointSetsModel()
 {
   ;
 }
 
 void QmitkCorrespondingPointSetsModel::RemoveObservers(){
   if (m_PointSetNode)
   {
     mitk::PointSet::Pointer oldPointSet = dynamic_cast<mitk::PointSet*>(m_PointSetNode->GetData());
     if (oldPointSet.IsNotNull())
     {
       oldPointSet->RemoveObserver(m_PointSetModifiedObserverTag);
     }
   }
   if (m_ReferencePointSetNode)
   {
     mitk::PointSet::Pointer oldPointSet = dynamic_cast<mitk::PointSet*>(m_ReferencePointSetNode->GetData());
     if (oldPointSet.IsNotNull())
     {
       oldPointSet->RemoveObserver(m_ReferencePointSetModifiedObserverTag);
     }
   }
 }
 
 void QmitkCorrespondingPointSetsModel::AddObservers()
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   if ( pointSet.IsNotNull())
   {
     // add new observer for modified if necessary
     itk::ReceptorMemberCommand<QmitkCorrespondingPointSetsModel>::Pointer modCommand = itk::ReceptorMemberCommand<QmitkCorrespondingPointSetsModel>::New();
     modCommand->SetCallbackFunction( this, &QmitkCorrespondingPointSetsModel::OnPointSetChanged );
     m_PointSetModifiedObserverTag = pointSet->AddObserver( itk::ModifiedEvent(), modCommand );
   }
   else
   {
     m_PointSetModifiedObserverTag = 0;
   }
 
   pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode);
   if ( pointSet.IsNotNull())
   {
     // add new observer for modified if necessary
     itk::ReceptorMemberCommand<QmitkCorrespondingPointSetsModel>::Pointer modCommand = itk::ReceptorMemberCommand<QmitkCorrespondingPointSetsModel>::New();
     modCommand->SetCallbackFunction( this, &QmitkCorrespondingPointSetsModel::OnPointSetChanged );
     m_ReferencePointSetModifiedObserverTag = pointSet->AddObserver( itk::ModifiedEvent(), modCommand );
   }
   else
   {
     m_ReferencePointSetModifiedObserverTag = 0;
   }
 }
 
 void QmitkCorrespondingPointSetsModel::OnPointSetChanged( const itk::EventObject &  /*e*/ )
 {
   QAbstractTableModel::reset();
 }
 void QmitkCorrespondingPointSetsModel::SetPointSetNodes( std::vector<mitk::DataNode*> nodes )
 {
   this->RemoveObservers();
   if ( nodes.size() > 1 )
   {
     m_PointSetNode = nodes.front();
     m_ReferencePointSetNode = nodes.back();
   }
   else if ( nodes.size() == 1 )
   {
     m_PointSetNode = nodes.front();
     m_ReferencePointSetNode = NULL;
   }
   else
   {
     m_PointSetNode = NULL;
     m_ReferencePointSetNode = NULL;
   }
   this->AddObservers();
   QAbstractTableModel::reset();
 }
 
 void QmitkCorrespondingPointSetsModel::SetTimeStep(int t)
 {
   if (!m_TimeStepper)
     return;
 
   m_TimeStepper->SetPos(t);
   QAbstractTableModel::reset();
 }
 
 int QmitkCorrespondingPointSetsModel::GetTimeStep() const
 {
   if (!m_TimeStepper)
     return 0;
 
   return m_TimeStepper->GetPos();
 }
 
 int QmitkCorrespondingPointSetsModel::rowCount( const QModelIndex&  /*parent*/ ) const
 {
   if (!m_TimeStepper)
     return 0;
 
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   mitk::PointSet::Pointer referencePointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode);
   int sizePS = 0;
   int sizeRPS = 0;
   if ( pointSet.IsNotNull() )
   {
     sizePS = pointSet->GetSize(m_TimeStepper->GetPos());
   }
   if ( referencePointSet.IsNotNull() )
   {
     sizeRPS = referencePointSet->GetSize(m_TimeStepper->GetPos());
   }
   if ( sizePS > sizeRPS )
     return sizePS;
   return sizeRPS;
 }
 
 int QmitkCorrespondingPointSetsModel::columnCount( const QModelIndex&  /*parent*/ ) const
 {
   return 2;
 }
 
 QVariant QmitkCorrespondingPointSetsModel::data(const QModelIndex& index, int role) const
 {
   mitk::PointSet::Pointer pointSet = NULL;
   if ( index.column() == 0 )
     pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   else if ( index.column() == 1 )
     pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode);
 
   if ( pointSet.IsNull() )
   {
     return QVariant();
   }
 
   if ( !index.isValid() )
   {
     return QVariant();
   }
 
   if ( index.row() >= pointSet->GetSize(m_TimeStepper->GetPos()) )
   {
     return QVariant();
   }
 
   if (role == Qt::DisplayRole)
   {
     mitk::PointSet::PointsContainer::ElementIdentifier id;
     mitk::PointSet::PointType p;
     bool pointFound = this->GetPointForModelIndex(index, p, id);
     if (pointFound == false)
       return QVariant();
 
     QString s = "";
     bool firstProp = true;
 
     if (this->QTPropIdsEnabled())
     {
       s.append(QString("%0").arg( id, 3));
       firstProp = false;
     }
     if (this->QTPropCoordinatesEnabled())
     {
       if(!firstProp)
         s.append(QString(": "));
       s.append(QString("(%0, %1, %2)")
       .arg( p[0], 0, 'f', 2 )
       .arg( p[1], 0, 'f', 2 )
       .arg( p[2], 0, 'f', 2 ));
     }
     return QVariant(s);
   }
   else
   {
     return QVariant();
   }
 }
 
 QVariant QmitkCorrespondingPointSetsModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (role != Qt::DisplayRole)
   {
     return QVariant();
   }
 
   if (orientation == Qt::Horizontal)
   {
     if (section == 0)
     {
       if ( m_PointSetNode )
         return QString::fromStdString(this->m_PointSetNode->GetName());
     }
     else if (section == 1)
     {
       if ( m_ReferencePointSetNode )
         return QString::fromStdString(this->m_ReferencePointSetNode->GetName());
     }
     return QString();
   }
   return QString("%1").arg(section);
 }
 
 bool QmitkCorrespondingPointSetsModel::GetPointForModelIndex( const QModelIndex &index, mitk::PointSet::PointType& p,
                                                              mitk::PointSet::PointIdentifier& id) const
 {
   if (!m_TimeStepper)
     return false;
 
   mitk::PointSet::Pointer pointSet = NULL;
   if ( index.column() == 0 )
     pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   else if ( index.column() == 1 )
     pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode);
 
   if (pointSet.IsNull() || !pointSet->GetPointSet(m_TimeStepper->GetPos()))
     return false;
 
   if ((index.row() < 0) || (index.row() >= (int)pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Size()))
     return false;
 
   // get the nth. element, if it exists.
   // we can not use the index directly, because PointSet uses a map container,
   // where the index is not necessarily the same as the key.
   // Therefore we have to count the elements
   mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin();
   for (int i = 0; i < index.row(); ++i)
   {
     ++it;
     if (it == pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End())
       return false;
   }
 
   if (it != pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End()) // not at the end,
   {
     p = it->Value();
     id = it->Index();
     return true;
   }
 
   return false;
 }
 bool QmitkCorrespondingPointSetsModel::GetPointForModelIndex( int row, int column, mitk::PointSet::PointType& p,
                                                              mitk::PointSet::PointIdentifier& id) const
 {
   if (!m_TimeStepper)
     return false;
 
   mitk::PointSet::Pointer pointSet = NULL;
   if (column == 0 )
     pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   else if ( column == 1 )
     pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode);
 
   if (pointSet.IsNull() || !pointSet->GetPointSet(m_TimeStepper->GetPos()))
     return false;
 
   if ((row < 0) || (row >= (int)pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Size()))
     return false;
 
   // get the nth. element, if it exists.
   // we can not use the index directly, because PointSet uses a map container,
   // where the index is not necessarily the same as the key.
   // Therefore we have to count the elements
   mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin();
   for (int i = 0; i < row; ++i)
   {
     ++it;
     if (it == pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End())
     return false;
   }
 
   if (it != pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End()) // not at the end,
   {
     p = it->Value();
     id = it->Index();
     return true;
   }
 
   return false;
 }
 
 bool QmitkCorrespondingPointSetsModel::GetModelIndexForPointID(mitk::PointSet::PointIdentifier id, QModelIndex& index, int column) const
 {
   if (!m_TimeStepper)
     return false;
 
   mitk::PointSet::Pointer pointSet = NULL;
   if (column == 0)
     pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   else if (column == 1)
     pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode);
 
   if (!pointSet.IsNull() || !pointSet->GetPointSet(m_TimeStepper->GetPos()))
   {
     mitk::PointSet::PointsContainer::Pointer points = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints();
 
     if (!points->IndexExists(id))
       return false;
 
     unsigned int idx = 0;
     for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); ++it)
     {
       if (it->Index() == id) // we found the correct element
       {
         index = this->index(idx, column);
         return true;
       }
 
       idx++;
     }
   }
   return false; // nothing found
 }
 
 bool QmitkCorrespondingPointSetsModel::GetModelIndexForSelectedPoint(QModelIndex& index) const
 {
   if (!m_TimeStepper)
     return false;
 
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0)
     dataNode = this->m_PointSetNode;
   else if (this->m_SelectedPointSetIndex == 1)
     dataNode = this->m_ReferencePointSetNode;
 
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode);
   if (pointSet.IsNull())
     return false;
 
   mitk::PointSet::PointIdentifier selectedID;
   selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos());
 
   return this->GetModelIndexForPointID(selectedID, index, this->m_SelectedPointSetIndex);
 }
 
 void QmitkCorrespondingPointSetsModel::MoveSelectedPointUp()
 {
   if (!m_TimeStepper)
     return;
 
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0)
     dataNode = this->m_PointSetNode;
   else if (this->m_SelectedPointSetIndex == 1)
     dataNode = this->m_ReferencePointSetNode;
 
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode);
   if (pointSet.IsNull())
     return;
 
   mitk::PointSet::PointIdentifier selectedID;
   selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos());
   if (selectedID==-1)
     return;
   mitk::PointSet::PointType point = pointSet->GetPoint(selectedID, m_TimeStepper->GetPos());
-  mitk::ScalarType tsInMS = pointSet->GetTimeSlicedGeometry()->TimeStepToMS(m_TimeStepper->GetPos());
+  mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStepper->GetPos());
   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP,tsInMS, pointSet->GetPoint(selectedID, m_TimeStepper->GetPos()), selectedID, true);
   pointSet->ExecuteOperation(doOp);
   QAbstractTableModel::reset();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   emit SignalPointSetChanged();
 }
 
 void QmitkCorrespondingPointSetsModel::MoveSelectedPointDown()
 {
   //QModelIndex;
   if (!m_TimeStepper)
     return;
 
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0)
     dataNode = this->m_PointSetNode;
   else if (this->m_SelectedPointSetIndex == 1)
     dataNode = this->m_ReferencePointSetNode;
 
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode);
   if (pointSet.IsNull())
     return;
 
   mitk::PointSet::PointIdentifier selectedID;
   selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos());
   if (selectedID==-1)
     return;
-  mitk::ScalarType tsInMS = pointSet->GetTimeSlicedGeometry()->TimeStepToMS(m_TimeStepper->GetPos());
+  mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStepper->GetPos());
   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, tsInMS, pointSet->GetPoint(selectedID, m_TimeStepper->GetPos()), selectedID, true);
   pointSet->ExecuteOperation(doOp);
 
   QAbstractTableModel::reset();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   emit SignalPointSetChanged();
 }
 
 mitk::PointSet::PointIdentifier QmitkCorrespondingPointSetsModel::SearchSelectedPoint()
 {
   if (!m_TimeStepper)
     return -1;
 
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0)
     dataNode = this->m_PointSetNode;
   else if (this->m_SelectedPointSetIndex == 1)
     dataNode = this->m_ReferencePointSetNode;
 
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode);
   if (pointSet.IsNull())
     return -1;
 
   return pointSet->SearchSelectedPoint(m_TimeStepper->GetPos());
 }
 
 void QmitkCorrespondingPointSetsModel::RemoveSelectedPoint()
 {
   if (!m_TimeStepper)
     return;
 
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0){
     dataNode = this->m_PointSetNode;
   }
   else if (this->m_SelectedPointSetIndex == 1){
     dataNode = this->m_ReferencePointSetNode;
   }
   if (dataNode == NULL)
     return;
 
   //send a DEL event to pointsetinteractor
   const mitk::Event* delEvent = new mitk::Event(this->m_MultiWidget->GetRenderWindow1()->GetRenderer(), mitk::Type_KeyPress, mitk::BS_NoButton, mitk::BS_NoButton, mitk::Key_Delete);
   mitk::StateEvent* delStateEvent = new mitk::StateEvent(mitk::EIDDELETE, delEvent);
   m_Interactor->HandleEvent(delStateEvent);
   delete delEvent;
   delete delStateEvent;
 
 
   QAbstractTableModel::reset();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   emit SignalPointSetChanged();
 }
 
 void QmitkCorrespondingPointSetsModel::MoveSelectedPoint(mitk::PointSet::PointIdentifier targetID)
 {
   if (!m_TimeStepper)
     return;
 
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0)
     dataNode = this->m_PointSetNode;
   else if (this->m_SelectedPointSetIndex == 1)
     dataNode = this->m_ReferencePointSetNode;
 
   if (dataNode == NULL)
     return;
 
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode);
   if (pointSet.IsNull())
     return;
 
   mitk::PointSet::PointIdentifier selectedID;
   selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos());
 
   if (targetID >= pointSet->GetSize())
     targetID = pointSet->GetSize()-1;
 
   mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin();
   for (int i=0; i<targetID; ++i)
     it++;
   targetID = it->Index();
 
   if (selectedID<0 || targetID<0)
     return;
 
   int direction = mitk::OpNOTHING;
   if (selectedID>targetID)
     direction = mitk::OpMOVEPOINTUP;
   else if (selectedID<targetID)
     direction = mitk::OpMOVEPOINTDOWN;
 
   while (selectedID!=targetID){
-    mitk::ScalarType tsInMS = pointSet->GetTimeSlicedGeometry()->TimeStepToMS(m_TimeStepper->GetPos());
+    mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStepper->GetPos());
     mitk::PointOperation* doOp = new mitk::PointOperation(direction, tsInMS, pointSet->GetPoint(selectedID, m_TimeStepper->GetPos()), selectedID, true);
     pointSet->ExecuteOperation(doOp);
     selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos());
   }
 
   QAbstractTableModel::reset();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   emit SignalPointSetChanged();
 }
 
 mitk::PointSet* QmitkCorrespondingPointSetsModel::CheckForPointSetInNode(mitk::DataNode* node) const
 {
   if (node != NULL)
   {
     mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
     if (pointSet.IsNotNull())
       return pointSet;
   }
   return NULL;
 }
 
 bool QmitkCorrespondingPointSetsModel::QTPropCoordinatesEnabled() const
 {
   return this->QTPropShowCoordinates;
 }
 
 void QmitkCorrespondingPointSetsModel::QTPropSetCoordinatesEnabled(bool showCoordinates)
 {
   this->QTPropShowCoordinates = showCoordinates;
 }
 
 bool QmitkCorrespondingPointSetsModel::QTPropIdsEnabled() const
 {
   return this->QTPropShowIds;
 }
 
 void QmitkCorrespondingPointSetsModel::QTPropSetIdsEnabled(bool showIds)
 {
   this->QTPropShowIds = showIds;
 }
 std::vector<mitk::DataNode*> QmitkCorrespondingPointSetsModel::GetPointSetNodes(){
   std::vector<mitk::DataNode*> pointSetNodes;
   if ( this->m_PointSetNode )
     pointSetNodes.push_back(this->m_PointSetNode);
   if ( this->m_ReferencePointSetNode )
     pointSetNodes.push_back(this->m_ReferencePointSetNode);
   return pointSetNodes;
 }
 
 void QmitkCorrespondingPointSetsModel::SetSelectedPointSetIndex(int index)
 {
   if (index<-1 || index>1)
     return;
   this->m_SelectedPointSetIndex = index;
 }
 
 void QmitkCorrespondingPointSetsModel::ClearSelectedPointSet()
 {
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0)
     dataNode = this->m_PointSetNode;
   else if (this->m_SelectedPointSetIndex == 1)
     dataNode = this->m_ReferencePointSetNode;
 
   if (dataNode == NULL)
     return;
 
   mitk::PointSet* pointSet = dynamic_cast<mitk::PointSet*>(dataNode->GetData());
 
   //pointSet->Clear();
   mitk::PointSet::PointsContainer::Iterator it;
   if (this->m_TimeStepper->GetRangeMax()==-1)
   {
     while( !pointSet->IsEmptyTimeStep(0) )
     {
       if (pointSet->GetPointSet(0))
       {
         it = pointSet->GetPointSet(0)->GetPoints()->Begin();
         pointSet->SetSelectInfo(it->Index(),true, 0);
         this->RemoveSelectedPoint();
       }
       else
       {
         break;
       }
     }
   }
   else
   {
     int oldTimeStep = this->m_TimeStepper->GetPos();
     for (int i=0; i<this->m_TimeStepper->GetRangeMax(); i++)
     {
       this->m_TimeStepper->SetPos(i);
       while( !pointSet->IsEmptyTimeStep(i) )
       {
         if (pointSet->GetPointSet(i))
         {
           it = pointSet->GetPointSet(i)->GetPoints()->Begin();
           pointSet->SetSelectInfo(it->Index(),true, i);
           this->RemoveSelectedPoint();
         }
       }
     }
     this->m_TimeStepper->SetPos(oldTimeStep);
   }
 
   QAbstractTableModel::reset();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   emit SignalPointSetChanged();
 }
 void QmitkCorrespondingPointSetsModel::ClearCurrentTimeStep()
 {
   if (!m_TimeStepper)
     return;
 
   mitk::DataNode* dataNode = NULL;
 
   if (this->m_SelectedPointSetIndex == 0)
     dataNode = this->m_PointSetNode;
   else if (this->m_SelectedPointSetIndex == 1)
     dataNode = this->m_ReferencePointSetNode;
 
   if (dataNode == NULL)
     return;
 
   mitk::PointSet* pointSet = dynamic_cast<mitk::PointSet*>(dataNode->GetData());
 
   mitk::PointSet::PointsContainer::Iterator it;
   while( !pointSet->IsEmptyTimeStep(m_TimeStepper->GetPos()) )
   {
     it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin();
     pointSet->SetSelectInfo(it->Index(),true, m_TimeStepper->GetPos());
     this->RemoveSelectedPoint();
   }
 
   QAbstractTableModel::reset();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   emit SignalPointSetChanged();
 }
 
 mitk::Stepper::Pointer QmitkCorrespondingPointSetsModel::GetStepper()
 {
   return this->m_TimeStepper;
 }
 void QmitkCorrespondingPointSetsModel::SetStepper(mitk::Stepper::Pointer stepper)
 {
   this->m_TimeStepper = stepper;
 }
 int QmitkCorrespondingPointSetsModel::GetSelectedPointSetIndex()
 {
   return this->m_SelectedPointSetIndex;
 }
 void QmitkCorrespondingPointSetsModel::UpdateSelection(mitk::DataNode* selectedNode)
 {
   this->RemoveInteractor();
   if(!selectedNode)
     return;
   m_Interactor = dynamic_cast<mitk::PointSetInteractor*>(selectedNode->GetInteractor());
   if (m_Interactor.IsNull())//if not present, instanciate one
     m_Interactor = mitk::PointSetInteractor::New("pointsetinteractor", selectedNode);
 
   //add it to global interaction to activate it
   mitk::GlobalInteraction::GetInstance()->AddInteractor( m_Interactor );
 }
 void QmitkCorrespondingPointSetsModel::RemoveInteractor()
 {
   if (m_Interactor){
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor( m_Interactor );
     m_Interactor = NULL;
   }
 }
 QmitkStdMultiWidget* QmitkCorrespondingPointSetsModel::GetMultiWidget()
 {
   return this->m_MultiWidget;
 }
 void QmitkCorrespondingPointSetsModel::SetMultiWidget( QmitkStdMultiWidget* multiWidget )
 {
   this->m_MultiWidget = multiWidget;
   this->m_TimeStepper = m_MultiWidget->GetTimeNavigationController()->GetTime();
 }
diff --git a/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp b/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp
index 804a2aef56..3a437c86fd 100644
--- a/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp
+++ b/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp
@@ -1,638 +1,639 @@
 /*===================================================================
 
 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 "QmitkThresholdComponent.h"
 #include "ui_QmitkThresholdComponentControls.h"
 
 
 #include <QmitkDataStorageComboBox.h>
 #include <mitkDataStorage.h>
 
 #include "mitkRenderingManager.h"
 #include "mitkProperties.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkImageWriteAccessor.h"
+#include <mitkTimeGeometry.h>
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <qlineedit.h>
 #include <qslider.h>
 #include <qgroupbox.h>
 #include <qcheckbox.h>
 #include <QIntValidator>
 
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 //#include <mitkIpPicTypeMultiplex.h>
 #include <itkImageConstIteratorWithIndex.h>
 
 
 /***************       CONSTRUCTOR      ***************/
 QmitkThresholdComponent::QmitkThresholdComponent(QObject * parent, const char * parentName, bool updateSelector, bool showSelector, QmitkStdMultiWidget * /*mitkStdMultiWidget*/)
 : QmitkFunctionalityComponentContainer(parent, parentName, updateSelector, showSelector),
 m_ThresholdImageNode(NULL),
 m_ThresholdComponentGUI(NULL),
 m_ThresholdNodeExisting(false)
 {
   SetAvailability(true);
 
   SetComponentName("ThresholdFinder");
 }
 
 /***************        DESTRUCTOR      ***************/
 QmitkThresholdComponent::~QmitkThresholdComponent()
 {
 
 }
 
 
 /************** SET SELECTOR VISIBILITY ***************/
 void QmitkThresholdComponent::SetSelectorVisibility(bool  /*visibility*/)
 {
   if(m_ThresholdComponentGUI)
   {
     //m_ImageContent->setShown(visibility);
     m_ImageContent->setShown(true);
   }
 }
 
 /***************   GET IMAGE CONTENT   ***************/
 QGroupBox* QmitkThresholdComponent::GetImageContent()
 {
   return (QGroupBox*) m_ImageContent;
 }
 
 
 /*************** GET TREE NODE SELECTOR ***************/
 QmitkDataStorageComboBox* QmitkThresholdComponent::GetTreeNodeSelector()
 {
   return m_TreeNodeSelector;
 }
 
 /***************       CONNECTIONS      ***************/
 void QmitkThresholdComponent::CreateConnections()
 {
   if ( m_ThresholdComponentGUI )
   {
     connect( (QObject*)(m_TreeNodeSelector), SIGNAL(OnSelectionChanged (const mitk::DataNode *)), (QObject*) this, SLOT(ImageSelected(const mitk::DataNode *)));
     connect( (QObject*)(m_ThresholdFinder), SIGNAL(toggled(bool)), (QObject*) this, SLOT(ShowThresholdFinderContent(bool)));
     connect( (QObject*)(m_ThresholdSelectDataGroupBox), SIGNAL(toggled(bool)), (QObject*) this, SLOT(ShowImageContent(bool)));
 
     connect( (QObject*)(m_ThresholdInputSlider), SIGNAL(sliderMoved(int)), (QObject*) this, SLOT(ThresholdSliderChanged(int)));
     connect( (QObject*)(m_ThresholdInputNumber), SIGNAL(returnPressed()), (QObject*) this, SLOT(ThresholdValueChanged()));
     //connect( (QObject*)( m_ShowThresholdGroupBox), SIGNAL(toggled(bool)), (QObject*) this, SLOT(ShowThreshold(bool)));
 
     //to connect the toplevel checkable GroupBox with the method SetContentContainerVisibility to inform all containing komponent to shrink or to expand
     connect( (QObject*)(m_ThresholdFinder),  SIGNAL(toggled(bool)), (QObject*) this, SLOT(SetContentContainerVisibility(bool)));
     connect( (QObject*)(m_CreateSegmentationButton),  SIGNAL(released()), (QObject*) this, SLOT(CreateThresholdSegmentation()));
   }
 }
 
 /***************     DATA STORAGE CHANGED     ***************/
 void  QmitkThresholdComponent::DataStorageChanged(mitk::DataStorage::Pointer ds)
 {
   if(!ds)
     return;
   m_DataStorage = ds;
   m_TreeNodeSelector->SetDataStorage(ds);
 
   if(m_ThresholdComponentGUI != NULL)
   {
     for(unsigned int i = 0;  i < m_AddedChildList.size(); i++)
     {
       QmitkBaseFunctionalityComponent* functionalityComponent = dynamic_cast<QmitkBaseFunctionalityComponent*>(m_AddedChildList[i]);
       if (functionalityComponent != NULL)
         functionalityComponent->DataStorageChanged(ds);
     }
   }
   if(!ds)
     return;
 
   DataObjectSelected();
   SetSliderRange();
   ShowThreshold();
 }
 
 /***************     IMAGE SELECTED     ***************/
 void QmitkThresholdComponent::ImageSelected(const mitk::DataNode* item)
 {
   if(m_ThresholdComponentGUI != NULL)
   {
     mitk::DataNode::Pointer selectedItem = const_cast< mitk::DataNode*>(item);
     m_TreeNodeSelector->SetSelectedNode(selectedItem);
     for(unsigned int i = 0;  i < m_AddedChildList.size(); i++)
     {
       QmitkBaseFunctionalityComponent* functionalityComponent = dynamic_cast<QmitkBaseFunctionalityComponent*>(m_AddedChildList[i]);
       if (functionalityComponent != NULL)
         functionalityComponent->ImageSelected(item);
     }
   }
   DataObjectSelected();
   SetSliderRange();
   ShowThreshold();
 }
 
 /***************  DATA OBJECT SELECTED   **************/
 void QmitkThresholdComponent::DataObjectSelected()
 {
   if(m_Active)
   {
     if(m_ThresholdNodeExisting)
     {
       m_ThresholdImageNode->SetData(m_TreeNodeSelector->GetSelectedNode()->GetData());
     }
     else
     {
       CreateThresholdImageNode();
       m_ThresholdImageNode->SetData(m_TreeNodeSelector->GetSelectedNode()->GetData());
     }
     ShowThreshold();
   }
 }
 
 /** \brief Method to set the DataStorage*/
 void QmitkThresholdComponent::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 /** \brief Method to get the DataStorage*/
 mitk::DataStorage::Pointer QmitkThresholdComponent::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 /*************** CREATE CONTAINER WIDGET **************/
 void QmitkThresholdComponent::CreateQtPartControl(QWidget * /*parent*/, mitk::DataStorage::Pointer dataStorage)
 {
   m_GUI = new QWidget;
   m_ThresholdComponentGUI = new Ui::QmitkThresholdComponentControls;
   m_ThresholdComponentGUI->setupUi(m_GUI);
 
 
 
   /*CREATE GUI ELEMENTS*/
 
   m_ThresholdFinder = new QGroupBox("2. Find Threshold", m_GUI);
   m_ThresholdSelectDataGroupBox = new QGroupBox("Show Image Selector", m_ThresholdFinder);
   m_TreeNodeSelector = new QmitkDataStorageComboBox(m_ThresholdSelectDataGroupBox);
   m_ImageContent = new QGroupBox("m_ImageContent", m_ThresholdSelectDataGroupBox);
   m_ContainerContent = new QGroupBox(m_ImageContent);
   m_ShowThresholdGroupBox = new QGroupBox("m_ShowThresholdGroupBox", m_ContainerContent);
   m_ThresholdInputNumber = new QLineEdit(m_ShowThresholdGroupBox);
   m_ThresholdInputSlider = new QSlider(m_ShowThresholdGroupBox);
   m_ThresholdInputSlider->setOrientation(Qt::Horizontal);
   m_ThresholdValueContent = new QGroupBox("m_ThresholdValueContent", m_ShowThresholdGroupBox);
   m_CreateSegmentationButton = new QPushButton("Create Segmentation", m_ThresholdValueContent);
   m_DeleateImageIfDeactivatedCheckBox = new QCheckBox("Deleate Threshold Image if \nComponent is deactivated", m_ThresholdValueContent);
 
   m_ThresholdFinder->setCheckable(true);
   m_ThresholdFinder->setChecked(true);
 
   m_ThresholdSelectDataGroupBox->setCheckable(true);
   m_ThresholdSelectDataGroupBox->setChecked(true);
 
   m_ThresholdInputNumber->setFixedSize(40, 20);
   QIntValidator* intValid = new QIntValidator(-32000, 5000, m_ThresholdInputNumber);
   m_ThresholdInputNumber->setValidator(intValid);
   m_ThresholdInputNumber->setText("0");
 
   m_ThresholdValueContent->setMaximumHeight(90);
 
   // m_ThresholdSelectDataGroupBox->setContentsMargins(0,9,9,9);
   // m_ImageContent->setContentsMargins(0,9,9,9);
   // m_ContainerContent->setContentsMargins(0,9,9,9);
   // m_ShowThresholdGroupBox->setContentsMargins(0,9,9,9);
   //m_ThresholdValueContent->setContentsMargins(0,9,9,9);
 
   //m_ThresholdFinder->setFlat(true);
   //m_ThresholdSelectDataGroupBox->setFlat(true);
   //m_ImageContent->setFlat(true);
   //m_ContainerContent->setFlat(true);
   //m_ShowThresholdGroupBox->setFlat(true);
   //m_ThresholdValueContent->setFlat(true);
 
 
 
   QVBoxLayout* guiLayout = new QVBoxLayout(m_GUI);
   m_GUI->setLayout(guiLayout);
   guiLayout->addWidget(m_ThresholdFinder);
 
   QVBoxLayout* thresholdFinderLayout = new QVBoxLayout(m_ThresholdFinder);
   thresholdFinderLayout->setContentsMargins(0,9,0,9);
   m_ThresholdFinder->setLayout(thresholdFinderLayout);
   thresholdFinderLayout->addWidget(m_ThresholdSelectDataGroupBox);
   thresholdFinderLayout->addWidget(m_ImageContent);
 
   QVBoxLayout* thresholdSelectDataGroupBoxLayout = new QVBoxLayout(m_ThresholdSelectDataGroupBox);
   thresholdSelectDataGroupBoxLayout->setContentsMargins(0,9,0,9);
   m_ThresholdSelectDataGroupBox->setLayout(thresholdSelectDataGroupBoxLayout);
   thresholdSelectDataGroupBoxLayout->addWidget(m_TreeNodeSelector);
 
 
   QVBoxLayout* imageContentLayout = new QVBoxLayout(m_ImageContent);
   imageContentLayout->setContentsMargins(0,9,0,9);
   m_ImageContent->setLayout(imageContentLayout);
   imageContentLayout->addWidget(m_ContainerContent);
 
   QVBoxLayout* containerContentLayout = new QVBoxLayout(m_ContainerContent);
   containerContentLayout->setContentsMargins(0,9,0,9);
   m_ContainerContent->setLayout(containerContentLayout);
   containerContentLayout->addWidget(m_ShowThresholdGroupBox);
 
   QVBoxLayout* showThresholdGroupBoxLayout = new QVBoxLayout(m_ShowThresholdGroupBox);
   showThresholdGroupBoxLayout->setContentsMargins(0,9,0,9);
   m_ShowThresholdGroupBox->setLayout(showThresholdGroupBoxLayout);
   QHBoxLayout* thresholdInputLayout = new QHBoxLayout(m_ShowThresholdGroupBox);
   thresholdInputLayout->addWidget(m_ThresholdInputNumber);
   thresholdInputLayout->addWidget(m_ThresholdInputSlider);
   showThresholdGroupBoxLayout->addLayout(thresholdInputLayout);
   showThresholdGroupBoxLayout->addWidget(m_ThresholdValueContent);
 
   QVBoxLayout* thresholdValueContentLayout = new QVBoxLayout(m_ThresholdValueContent);
   thresholdValueContentLayout->setContentsMargins(0,9,0,9);
   m_ThresholdValueContent->setLayout(thresholdValueContentLayout);
   thresholdValueContentLayout->addWidget(m_DeleateImageIfDeactivatedCheckBox);
   thresholdValueContentLayout->addWidget(m_CreateSegmentationButton);
 
   this->CreateConnections();
   SetDataStorage(dataStorage);
 
   m_TreeNodeSelector->SetDataStorage(dataStorage);
   m_TreeNodeSelector->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 
   if(m_ShowSelector)
   {
     m_ImageContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
     //m_ImageContent->setShown(true);
   }
   else
   {
     m_ThresholdSelectDataGroupBox->setShown(m_ShowSelector);
     //m_ThresholdSelectDataGroupBox->setShown(true);
   }
 }
 
 /*************** GET CONTENT CONTAINER  ***************/
 QGroupBox * QmitkThresholdComponent::GetContentContainer()
 {
   return  m_ContainerContent;
 }
 
 /************ GET MAIN CHECK BOX CONTAINER ************/
 QGroupBox * QmitkThresholdComponent::GetMainCheckBoxContainer()
 {
   return  m_ThresholdFinder;
 }
 
 ///*********** SET CONTENT CONTAINER VISIBLE ************/
 //void QmitkThresholdComponent::SetContentContainerVisibility()
 //{
 //     for(unsigned int i = 0;  i < m_AddedChildList.size(); i++)
 //    {
 //      if(m_AddedChildList[i]->GetContentContainer() != NULL)
 //      {
 //        m_AddedChildList[i]->GetContentContainer()->setShown(GetMainCheckBoxContainer()->isChecked());
 //      }
 //    }
 //}
 
 /***************        ACTIVATED       ***************/
 void QmitkThresholdComponent::Activated()
 {
   QmitkBaseFunctionalityComponent::Activated();
   m_Active = true;
   for(unsigned int i = 0;  i < m_AddedChildList.size(); i++)
   {
     m_AddedChildList[i]->Activated();
   }
   CreateThresholdImageNode();
   ShowThreshold();
   SetSliderRange();
 }
 
 /***************       DEACTIVATED      ***************/
 void QmitkThresholdComponent::Deactivated()
 {
   QmitkBaseFunctionalityComponent::Deactivated();
   m_Active = false;
   for(unsigned int i = 0;  i < m_AddedChildList.size(); i++)
   {
     m_AddedChildList[i]->Deactivated();
   }
   ShowThreshold();
   if( m_DeleateImageIfDeactivatedCheckBox->isChecked())
   {
     DeleteThresholdNode();
   }
 }
 
 ///************ SHOW THRESHOLD FINDER CONTENT ***********/
 void QmitkThresholdComponent::ShowThresholdFinderContent(bool)
 {
   // m_ShowThresholdGroupBox->setShown( m_ThresholdFinder->isChecked());
   // m_ContainerContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
   m_ContainerContent->setShown( m_ThresholdFinder->isChecked());
 
 
   if(m_ShowSelector)
   {
     //m_ThresholdSelectDataGroupBox->setShown( m_ThresholdSelectDataGroupBox->isChecked());
     //m_ThresholdSelectDataGroupBox->setShown( true);
     m_ThresholdSelectDataGroupBox->setShown(m_ThresholdFinder->isChecked());
   }
 
   //ShowThreshold();
 }
 
 ///***************    SHOW IMAGE CONTENT   **************/
 void QmitkThresholdComponent::ShowImageContent(bool)
 {
   //m_ImageContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
   m_ImageContent->setShown( true);
 
   if(m_ShowSelector)
   {
     //m_ImageContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
     m_ImageContent->setShown( true);
   }
   else
   {
     //m_ThresholdSelectDataGroupBox->setShown(m_ShowSelector);
     m_ThresholdSelectDataGroupBox->setShown(true);
   }
 }
 
 ///***************      SHOW THRESHOLD     **************/
 void QmitkThresholdComponent::ShowThreshold(bool)
 {
   if(m_ThresholdImageNode)
   {
     if(m_Active == true)
     {
       m_ThresholdImageNode->SetProperty("visible", mitk::BoolProperty::New(( m_ThresholdFinder->isChecked())) );
     }
     else
     {
       if( m_DeleateImageIfDeactivatedCheckBox->isChecked())
       {
         m_ThresholdImageNode->SetProperty("visible", mitk::BoolProperty::New((false)) );
       }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 ///*************** THRESHOLD VALUE CHANGED **************/
 //By Slider
 void QmitkThresholdComponent::ThresholdSliderChanged(int)
 {
   int value =  m_ThresholdInputSlider->value();
   if (m_ThresholdImageNode)
   {
     m_ThresholdImageNode->SetLevelWindow(mitk::LevelWindow(value,1));
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   m_ThresholdInputNumber->setText(QString::number(value));
 }
 
 ///*************** THRESHOLD VALUE CHANGED **************/
 //By LineEdit
 void QmitkThresholdComponent::ThresholdValueChanged( )
 {
   int value = atoi( m_ThresholdInputNumber->text().toLocal8Bit().constData() );
   if (m_ThresholdImageNode)
   {
     m_ThresholdImageNode->SetLevelWindow(mitk::LevelWindow(value,1));
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   m_ThresholdInputSlider->setValue(value);
 }
 
 
 ///***************     SET SLIDER RANGE    **************/
 void QmitkThresholdComponent::SetSliderRange()
 {
   if(m_Active)
   {
     if( m_ThresholdFinder->isChecked()==true)
     {
       if(!m_TreeNodeSelector->GetSelectedNode())
         return;
       if(!m_TreeNodeSelector->GetSelectedNode()->GetData())
         return;
       mitk::Image* currentImage = dynamic_cast<mitk::Image*>(m_TreeNodeSelector->GetSelectedNode()->GetData());
       if(currentImage)
       {
         int min = (int) currentImage->GetScalarValueMin();
         int max = (int) currentImage->GetScalarValueMaxNoRecompute();
         //int realMax = currentImage->GetScalarValueMax();
         if(min < -32000)
         {
           min = (int) currentImage->GetScalarValue2ndMin();
           max = (int) currentImage->GetScalarValue2ndMaxNoRecompute();
         }
 
         QIntValidator* intValid = new QIntValidator(min-150, max+150, m_ThresholdInputNumber);
         m_ThresholdInputNumber->setValidator(intValid);
         m_ThresholdInputNumber->setText("1");
 
         m_ThresholdInputSlider->setMinimum(min-150);
         m_ThresholdInputSlider->setMaximum(max+150);
         m_ThresholdInputSlider->setRange(min-150, max+150);
         m_ThresholdInputSlider->setPageStep(1);
         m_ThresholdInputSlider->setValue(1);
 
         m_GUI->repaint();
         //m_ThresholdInputSlider->resize();
 
         /* m_ThresholdInputSlider->setMinValue((int)currentImage->GetScalarValueMin());
         m_ThresholdInputSlider->setMaxValue((int)currentImage->GetScalarValueMaxNoRecompute());*/
       }
     }
   }
 }
 
 ///***************  DELETE THRESHOLD NODE  **************/
 void QmitkThresholdComponent::DeleteThresholdNode()
 {
   if(m_ThresholdImageNode)
   {
 
     mitk::DataNode::Pointer foundNode = m_DataStorage->GetNamedNode("Thresholdview image");
     foundNode->Delete();
 
 
     m_ThresholdNodeExisting = false;
     return;
   }
 }
 ///*************CREATE THRESHOLD IMAGE NODE************/
 void QmitkThresholdComponent::CreateThresholdImageNode()
 {
   if(m_Active)
   {
     if( m_ThresholdNodeExisting)
       return;
     if(!m_TreeNodeSelector)
       return;
     if(!m_TreeNodeSelector->GetSelectedNode())
       return;
     m_ThresholdImageNode = mitk::DataNode::New();
     mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New("Thresholdview image" );
     m_ThresholdImageNode->SetProperty( "name", nameProp );
     mitk::BoolProperty::Pointer componentThresholdImageProp = mitk::BoolProperty::New(true);
     m_ThresholdImageNode->SetProperty( "isComponentThresholdImage", componentThresholdImageProp );
     m_ThresholdImageNode->SetData(m_TreeNodeSelector->GetSelectedNode()->GetData());
     m_ThresholdImageNode->SetColor(0.0,1.0,0.0);
     m_ThresholdImageNode->SetOpacity(.25);
     int layer = 0;
     m_ThresholdImageNode->GetIntProperty("layer", layer);
     m_ThresholdImageNode->SetIntProperty("layer", layer+1);
     m_ThresholdImageNode->SetLevelWindow(mitk::LevelWindow(atoi( m_ThresholdInputNumber->text().toLocal8Bit().constData()),1));
     m_ThresholdNodeExisting = true;
     m_DataStorage->Add(m_ThresholdImageNode);
 
   }
 }
 
 /*************CREAET THRESHOLD SEGMENTATION************/
 void QmitkThresholdComponent::CreateThresholdSegmentation()
 {
   mitk::Image::Pointer original = dynamic_cast<mitk::Image*>(m_TreeNodeSelector->GetSelectedNode()->GetData());
   // we NEED a reference image for size etc.
   if (!original) return;
 
   // actually create a new empty segmentation
   mitk::PixelType pixelType( mitk::MakeScalarPixelType<DefaultSegmentationDataType>() );
   mitk::Image::Pointer segmentation = mitk::Image::New();
   //segmentation->SetProperty( "organ type", OrganTypeProperty::New( organType ) );
 
   segmentation->Initialize( pixelType, original->GetDimension(), original->GetDimensions() );
 
   unsigned int byteSize = sizeof(DefaultSegmentationDataType);
   for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
   {
     byteSize *= segmentation->GetDimension(dim);
   }
   mitk::ImageWriteAccessor writeAccess(segmentation, segmentation->GetVolumeData(0));
   memset( writeAccess.GetData() , 0, byteSize );
 
-  if (original->GetTimeSlicedGeometry() )
+  if (original->GetTimeGeometry() )
   {
-    mitk::TimeSlicedGeometry::Pointer originalGeometry = original->GetTimeSlicedGeometry()->Clone();
-    segmentation->SetGeometry( originalGeometry );
+    itk::LightObject::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
+    segmentation->SetTimeGeometry( dynamic_cast<mitk::TimeGeometry *> (originalGeometry.GetPointer()) );
   }
   else
   {
     MITK_INFO<<"Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.";
     return ;
   }
 
   mitk::DataNode::Pointer emptySegmentationNode = CreateSegmentationNode( segmentation);
 
   if (emptySegmentationNode)
   {
     // actually perform a thresholding and ask for an organ type
     for (unsigned int timeStep = 0; timeStep < original->GetTimeSteps(); ++timeStep)
     {
       try
       {
         mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
         timeSelector->SetInput( original );
         timeSelector->SetTimeNr( timeStep );
         timeSelector->UpdateLargestPossibleRegion();
         mitk::Image::Pointer image3D = timeSelector->GetOutput();
 
         AccessFixedDimensionByItk_2( image3D, ITKThresholding, 3, dynamic_cast<mitk::Image*>(emptySegmentationNode->GetData()), timeStep );
       }
       catch(...)
       {
         MITK_INFO<<"Error accessing single time steps of the original image. Cannot create segmentation.";
       }
     }
 
     mitk::DataNode::Pointer originalNode = m_TreeNodeSelector->GetSelectedNode();
     m_DataStorage->Add( emptySegmentationNode, originalNode ); // add as a child, because the segmentation "derives" from the original
 
   }
 }
 
 mitk::DataNode::Pointer QmitkThresholdComponent::CreateSegmentationNode( mitk::Image* image)
 {
 
   if (!image) return NULL;
 
   // decorate the datatreenode with some properties
   mitk::DataNode::Pointer segmentationNode = mitk::DataNode::New();
   segmentationNode->SetData( image );
 
   // name
   segmentationNode->SetProperty( "name", mitk::StringProperty::New( "TH segmentation from ThresholdFinder" ) );
 
   // visualization properties
   segmentationNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
   segmentationNode->SetProperty( "color", mitk::ColorProperty::New(0.0, 1.0, 0.0) );
   segmentationNode->SetProperty( "texture interpolation", mitk::BoolProperty::New(false) );
   segmentationNode->SetProperty( "layer", mitk::IntProperty::New(10) );
   segmentationNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0.5, 1) ) );
   segmentationNode->SetProperty( "opacity", mitk::FloatProperty::New(0.3) );
   segmentationNode->SetProperty( "segmentation", mitk::BoolProperty::New(true) );
   segmentationNode->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
 
   return segmentationNode;
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void QmitkThresholdComponent::ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, mitk::Image* segmentation, unsigned int timeStep )
 {
   mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
   timeSelector->SetInput( segmentation );
   timeSelector->SetTimeNr( timeStep );
   timeSelector->UpdateLargestPossibleRegion();
   mitk::Image::Pointer segmentation3D = timeSelector->GetOutput();
 
   typedef itk::Image< DefaultSegmentationDataType, 3> SegmentationType; // this is sure for new segmentations
   SegmentationType::Pointer itkSegmentation;
   CastToItkImage( segmentation3D, itkSegmentation );
 
   // iterate over original and segmentation
   typedef itk::ImageRegionConstIterator< itk::Image<TPixel, VImageDimension> >     InputIteratorType;
   typedef itk::ImageRegionIterator< SegmentationType >     SegmentationIteratorType;
 
   InputIteratorType inputIterator( originalImage, originalImage->GetLargestPossibleRegion() );
   SegmentationIteratorType outputIterator( itkSegmentation, itkSegmentation->GetLargestPossibleRegion() );
 
   inputIterator.GoToBegin();
   outputIterator.GoToBegin();
 
   while (!outputIterator.IsAtEnd())
   {
     if ( (signed)inputIterator.Get() >= atoi( m_ThresholdInputNumber->text().toLocal8Bit().constData()) )
     {
       outputIterator.Set( 1 );
     }
     else
     {
       outputIterator.Set( 0 );
     }
 
     ++inputIterator;
     ++outputIterator;
   }
 }
diff --git a/Modules/QmitkExt/QmitkPointListModel.cpp b/Modules/QmitkExt/QmitkPointListModel.cpp
index da517c654f..9197476c35 100644
--- a/Modules/QmitkExt/QmitkPointListModel.cpp
+++ b/Modules/QmitkExt/QmitkPointListModel.cpp
@@ -1,335 +1,335 @@
 /*===================================================================
 
 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 "QmitkPointListModel.h"
 #include <itkCommand.h>
 #include "mitkInteractionConst.h"
 #include "mitkPointOperation.h"
 #include "mitkRenderingManager.h"
 #include <mitkPointSetInteractor.h>
 #include <mitkEvent.h>
 #include <mitkStateEvent.h>
 #include <mitkInteractionConst.h>
 
 
 QmitkPointListModel::QmitkPointListModel( mitk::DataNode* pointSetNode, int t, QObject* parent )
 :QAbstractListModel(parent),
 m_PointSetNode(NULL),
 m_PointSetModifiedObserverTag(0),
 m_PointSetDeletedObserverTag(0),
 m_TimeStep(t)
 {
   ObserveNewPointSet( pointSetNode );
 }
 
 Qt::ItemFlags QmitkPointListModel::flags(const QModelIndex& /*index*/) const
 {
   // no editing so far, return default (enabled, selectable)
   return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 }
 
 QmitkPointListModel::~QmitkPointListModel()
 {
   this->ObserveNewPointSet( NULL );
 }
 
 void QmitkPointListModel::SetPointSetNode( mitk::DataNode* pointSetNode )
 {
   this->ObserveNewPointSet( pointSetNode );
   QAbstractListModel::reset();
   emit SignalUpdateSelection();
 }
 
 mitk::PointSet* QmitkPointListModel::GetPointSet() const
 {
   return this->CheckForPointSetInNode(m_PointSetNode);
 }
 
 void QmitkPointListModel::SetTimeStep(int t)
 {
   m_TimeStep = t;
   QAbstractListModel::reset();
   emit SignalUpdateSelection();
 }
 
 int QmitkPointListModel::GetTimeStep() const
 {
   return m_TimeStep;
 }
 
 void QmitkPointListModel::ObserveNewPointSet( mitk::DataNode* pointSetNode )
 {
 
   //remove old observers
   if (m_PointSetNode != NULL)
   {
     mitk::PointSet::Pointer oldPointSet = dynamic_cast<mitk::PointSet*>(m_PointSetNode->GetData());
     if (oldPointSet.IsNotNull())
     {
       oldPointSet->RemoveObserver(m_PointSetModifiedObserverTag);
       oldPointSet->RemoveObserver(m_PointSetDeletedObserverTag);
     }
   }
 
   //get the new pointset
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(pointSetNode);
 
   m_PointSetNode = pointSetNode;
 
   if ( pointSet.IsNotNull())
   {
     // add new observer for modified if necessary
     itk::ReceptorMemberCommand<QmitkPointListModel>::Pointer modCommand = itk::ReceptorMemberCommand<QmitkPointListModel>::New();
     modCommand->SetCallbackFunction( this, &QmitkPointListModel::OnPointSetChanged );
     m_PointSetModifiedObserverTag = pointSet->AddObserver( itk::ModifiedEvent(), modCommand );
 
     // add new observer for detele if necessary
     itk::ReceptorMemberCommand<QmitkPointListModel>::Pointer delCommand = itk::ReceptorMemberCommand<QmitkPointListModel>::New();
     delCommand->SetCallbackFunction( this, &QmitkPointListModel::OnPointSetDeleted );
     m_PointSetDeletedObserverTag = pointSet->AddObserver( itk::DeleteEvent(), delCommand );
   }
   else
   {
     m_PointSetModifiedObserverTag = 0;
     m_PointSetDeletedObserverTag = 0;
   }
 }
 
 void QmitkPointListModel::OnPointSetChanged( const itk::EventObject &  /*e*/ )
 {
   QAbstractListModel::reset();
   emit SignalUpdateSelection();
 }
 
 void QmitkPointListModel::OnPointSetDeleted( const itk::EventObject &  /*e*/ )
 {
 //  m_PointSetNode = NULL;
   mitk::PointSet::Pointer ps = CheckForPointSetInNode(m_PointSetNode);
   if (ps)
   {
     ps->RemoveObserver(m_PointSetModifiedObserverTag);
     ps->RemoveObserver(m_PointSetDeletedObserverTag);
   }
 
   m_PointSetModifiedObserverTag = 0;
   m_PointSetDeletedObserverTag = 0;
   QAbstractListModel::reset();
 }
 
 int QmitkPointListModel::rowCount( const QModelIndex&  /*parent*/ ) const
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   if ( pointSet.IsNotNull() )
   {
     return pointSet->GetSize(m_TimeStep);
   }
   else
   {
     return 0;
   }
 }
 
 QVariant QmitkPointListModel::data(const QModelIndex& index, int role) const
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
 
   if ( pointSet.IsNull() )
   {
     return QVariant();
   }
 
   if ( !index.isValid() )
   {
     return QVariant();
   }
 
   if ( index.row() >= pointSet->GetSize(m_TimeStep) )
   {
     return QVariant();
   }
 
   if (role == Qt::DisplayRole)
   {
     mitk::PointSet::PointsContainer::ElementIdentifier id;
     mitk::PointSet::PointType p;
     bool pointFound = this->GetPointForModelIndex(index, p, id);
     if (pointFound == false)
       return QVariant();
 
     QString s = QString("%0: (%1, %2, %3)")
       .arg( id, 3)
       .arg( p[0], 0, 'f', 3 )
       .arg( p[1], 0, 'f', 3 )
       .arg( p[2], 0, 'f', 3 );
     return QVariant(s);
   }
   else
   {
     return QVariant();
   }
 }
 
 QVariant QmitkPointListModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (role != Qt::DisplayRole)
   {
     return QVariant();
   }
 
   if (orientation == Qt::Horizontal)
   {
     return QString("Coordinates").arg(section);
   }
   else
   {
     return QString("Row %1").arg(section);
   }
 }
 
 bool QmitkPointListModel::GetPointForModelIndex( const QModelIndex &index, mitk::PointSet::PointType& p,
                                                 mitk::PointSet::PointIdentifier& id) const
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   if (pointSet.IsNull())
     return false;
 
   if ((index.row() < 0) || (index.row() >= (int)pointSet->GetPointSet(m_TimeStep)->GetPoints()->Size()))
     return false;
 
   // get the nth. element, if it exists.
   // we can not use the index directly, because PointSet uses a map container,
   // where the index is not necessarily the same as the key.
   // Therefore we have to count the elements
   mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStep)->GetPoints()->Begin();
   for (int i = 0; i < index.row(); ++i)
   {
     ++it;
 
     if (it == pointSet->GetPointSet(m_TimeStep)->GetPoints()->End())
       return false;
 
   }
 
   if (it != pointSet->GetPointSet(m_TimeStep)->GetPoints()->End()) // not at the end,
   {
     p = it->Value();
     id = it->Index();
     return true;
   }
 
   return false;
 }
 
 bool QmitkPointListModel::GetModelIndexForPointID(mitk::PointSet::PointIdentifier id, QModelIndex& index) const
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   if (pointSet.IsNull())
     return false;
 
   mitk::PointSet::PointsContainer::Pointer points = pointSet->GetPointSet(m_TimeStep)->GetPoints();
 
   if (points->IndexExists(id) == false)
     return false;
 
   unsigned int idx = 0;
   for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); ++it)
   {
     if (it->Index() == id) // we found the correct element
     {
       index = this->index(idx);
       return true;
     }
 
     idx++;
   }
 
   return false; // nothing found
 }
 
 void QmitkPointListModel::MoveSelectedPointUp()
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   if (pointSet.IsNull())
     return;
 
   mitk::PointSet::PointIdentifier selectedID;
   selectedID = pointSet->SearchSelectedPoint(m_TimeStep);
   mitk::PointSet::PointType point = pointSet->GetPoint(selectedID, m_TimeStep);
-  mitk::ScalarType tsInMS = pointSet->GetTimeSlicedGeometry()->TimeStepToMS(m_TimeStep);
+  mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStep);
   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP,tsInMS, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true);
   pointSet->ExecuteOperation(doOp);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper
 }
 
 void QmitkPointListModel::MoveSelectedPointDown()
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   if (pointSet.IsNull())
     return;
 
   mitk::PointSet::PointIdentifier selectedID;
   selectedID = pointSet->SearchSelectedPoint(m_TimeStep);
-  mitk::ScalarType tsInMS = pointSet->GetTimeSlicedGeometry()->TimeStepToMS(m_TimeStep);
+  mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStep);
   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, tsInMS, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true);
   pointSet->ExecuteOperation(doOp);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper
 }
 
 
 void QmitkPointListModel::RemoveSelectedPoint()
 {
   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
   if (pointSet.IsNull())
     return;
 
   //get corresponding interactor to PointSet
   mitk::PointSetInteractor::Pointer interactor = dynamic_cast<mitk::PointSetInteractor*>(m_PointSetNode->GetInteractor());
   if (interactor.IsNull())
   {
     if (m_PointSetNode->GetInteractor()==NULL && m_PointSetNode != NULL) //no Interactor set to node
     {
       interactor = mitk::PointSetInteractor::New("pointsetinteractor",m_PointSetNode);
       m_PointSetNode->SetInteractor(interactor);
     }
     else
     {
       MITK_WARN<<"Unexpected interactor found!\n";
       return;
     }
   }
 
 
   //send a DEL event to pointsetinteractor
   const mitk::Event* delEvent = new mitk::Event(NULL, mitk::Type_KeyPress, mitk::BS_NoButton, mitk::BS_NoButton, mitk::Key_Delete);
   mitk::StateEvent* delStateEvent = new mitk::StateEvent(mitk::EIDDELETE, delEvent);
   interactor->HandleEvent(delStateEvent);
   delete delEvent;
   delete delStateEvent;
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in PointSet/Mapper
 }
 
 mitk::PointSet* QmitkPointListModel::CheckForPointSetInNode(mitk::DataNode* node) const
 {
   if (node != NULL)
   {
     mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
     if (pointSet.IsNotNull())
       return pointSet;
   }
   return NULL;
 }
 
diff --git a/Modules/QmitkExt/QmitkSliceWidget.cpp b/Modules/QmitkExt/QmitkSliceWidget.cpp
index 00a1d502ae..f007f58088 100644
--- a/Modules/QmitkExt/QmitkSliceWidget.cpp
+++ b/Modules/QmitkExt/QmitkSliceWidget.cpp
@@ -1,344 +1,341 @@
 /*===================================================================
 
 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 "QmitkSliceWidget.h"
 #include "QmitkStepperAdapter.h"
 #include "mitkNodePredicateDataType.h"
+
+#include <mitkProportionalTimeGeometry.h>
+
+
 //#include "QmitkRenderWindow.h"
 //
 //#include "mitkSliceNavigationController.h"
 //#include "QmitkLevelWindowWidget.h"
 //
 //#include <vtkRenderer.h>
 //#include "mitkRenderingManager.h"
 
 #include <QMenu>
 #include <QMouseEvent>
 
 QmitkSliceWidget::QmitkSliceWidget(QWidget* parent, const char* name,
     Qt::WindowFlags f) :
   QWidget(parent, f)
 {
   this->setupUi(this);
 
   if (name != 0)
     this->setObjectName(name);
 
   popUp = new QMenu(this);
   popUp->addAction("Axial");
   popUp->addAction("Frontal");
   popUp->addAction("Sagittal");
 
   QObject::connect(popUp, SIGNAL(triggered(QAction*)), this, SLOT(ChangeView(QAction*)) );
   setPopUpEnabled(false);
 
   m_SlicedGeometry = 0;
   m_View = mitk::SliceNavigationController::Axial;
 
   QHBoxLayout *hlayout = new QHBoxLayout(container);
   hlayout->setMargin(0);
 
   // create widget
   QString composedName("QmitkSliceWidget::");
   if (!this->objectName().isEmpty())
     composedName += this->objectName();
   else
     composedName += "QmitkGLWidget";
   m_RenderWindow = new QmitkRenderWindow(container, composedName);
   m_Renderer = m_RenderWindow->GetRenderer();
   hlayout->addWidget(m_RenderWindow);
 
   new QmitkStepperAdapter(m_NavigatorWidget,
       m_RenderWindow->GetSliceNavigationController()->GetSlice(),
       "navigation");
 
   SetLevelWindowEnabled(true);
 
 }
 
 mitk::VtkPropRenderer* QmitkSliceWidget::GetRenderer()
 {
   return m_Renderer;
 }
 
 QFrame* QmitkSliceWidget::GetSelectionFrame()
 {
   return SelectionFrame;
 }
 
 void QmitkSliceWidget::SetDataStorage(
     mitk::StandaloneDataStorage::Pointer storage)
 {
   m_DataStorage = storage;
   m_Renderer->SetDataStorage(m_DataStorage);
 }
 
 mitk::StandaloneDataStorage* QmitkSliceWidget::GetDataStorage()
 {
   if (m_DataStorage.IsNotNull())
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 void QmitkSliceWidget::SetData(
     mitk::DataStorage::SetOfObjects::ConstIterator it)
 {
   SetData(it->Value(), m_View);
 }
 
 void QmitkSliceWidget::SetData(
     mitk::DataStorage::SetOfObjects::ConstIterator it,
     mitk::SliceNavigationController::ViewDirection view)
 {
   SetData(it->Value(), view);
 }
 
 void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node)
 {
   try
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(node);
     }
   } catch (...)
   {
   }
   SetData(node, m_View);
 }
 
 //void QmitkSliceWidget::AddData( mitk::DataNode::Pointer node)
 //{
 //  if ( m_DataTree.IsNull() )
 //  {
 //    m_DataTree = mitk::DataTree::New();
 //  }
 //  mitk::DataTreePreOrderIterator it(m_DataTree);
 //  it.Add( node );
 //  SetData(&it, m_View);
 //}
 
 
 void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node,
     mitk::SliceNavigationController::ViewDirection view)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
 
   if (image.IsNull())
   {
     MITK_WARN << "QmitkSliceWidget data is not an image!";
     return;
   }
 
   m_SlicedGeometry = image->GetSlicedGeometry();
   this->InitWidget(view);
 }
 
 void QmitkSliceWidget::InitWidget(
     mitk::SliceNavigationController::ViewDirection viewDirection)
 {
   m_View = viewDirection;
 
   mitk::SliceNavigationController* controller =
       m_RenderWindow->GetSliceNavigationController();
 
   if (viewDirection == mitk::SliceNavigationController::Axial)
   {
     controller->SetViewDirection(
         mitk::SliceNavigationController::Axial);
   }
   else if (viewDirection == mitk::SliceNavigationController::Frontal)
   {
     controller->SetViewDirection(mitk::SliceNavigationController::Frontal);
   }
   // init sagittal view
   else
   {
     controller->SetViewDirection(mitk::SliceNavigationController::Sagittal);
   }
 
   int currentPos = 0;
   if (m_RenderWindow->GetSliceNavigationController())
   {
     currentPos = controller->GetSlice()->GetPos();
   }
 
   if (m_SlicedGeometry.IsNull())
   {
     return;
   }
 
   // compute bounding box with respect to first images geometry
   const mitk::BoundingBox::BoundsArrayType imageBounds =
       m_SlicedGeometry->GetBoundingBox()->GetBounds();
 
   //  mitk::SlicedGeometry3D::Pointer correctGeometry = m_SlicedGeometry.GetPointer();
   mitk::Geometry3D::Pointer
       geometry =
           static_cast<mitk::Geometry3D*> (m_SlicedGeometry->Clone().GetPointer());
 
   const mitk::BoundingBox::Pointer boundingbox =
       m_DataStorage->ComputeVisibleBoundingBox(GetRenderer(), NULL);
   if (boundingbox->GetPoints()->Size() > 0)
   {
     ////geometry = mitk::Geometry3D::New();
     ////geometry->Initialize();
     //geometry->SetBounds(boundingbox->GetBounds());
     //geometry->SetSpacing(correctGeometry->GetSpacing());
 
     //let's see if we have data with a limited live-span ...
     mitk::TimeBounds timebounds = m_DataStorage->ComputeTimeBounds(
         GetRenderer(), NULL);
 
     if (timebounds[1] < mitk::ScalarTypeNumericTraits::max())
     {
       mitk::ScalarType duration = timebounds[1] - timebounds[0];
 
-      mitk::TimeSlicedGeometry::Pointer timegeometry =
-          mitk::TimeSlicedGeometry::New();
-
-      timegeometry->InitializeEvenlyTimed(geometry.GetPointer(),
-          (unsigned int) duration);
-
-      timegeometry->SetTimeBounds(timebounds); //@bug really required? FIXME
-
       timebounds[1] = timebounds[0] + 1.0f;
       geometry->SetTimeBounds(timebounds);
-
-      geometry = timegeometry;
     }
 
-    if (const_cast<mitk::BoundingBox*> (geometry->GetBoundingBox())->GetDiagonalLength2()
+    mitk::ProportionalTimeGeometry::Pointer timeGeometry = mitk::ProportionalTimeGeometry::New();
+    timeGeometry->Initialize(geometry,1);
+
+    if (const_cast<mitk::BoundingBox*> (timeGeometry->GetBoundingBoxInWorld())->GetDiagonalLength2()
         >= mitk::eps)
     {
-      controller->SetInputWorldGeometry(geometry);
+      controller->SetInputWorldTimeGeometry(timeGeometry);
       controller->Update();
     }
   }
 
   GetRenderer()->GetDisplayGeometry()->Fit();
   mitk::RenderingManager::GetInstance()->RequestUpdate(
       GetRenderer()->GetRenderWindow());
   //int w=vtkObject::GetGlobalWarningDisplay();
   //vtkObject::GlobalWarningDisplayOff();
   //vtkRenderer * vtkrenderer = ((mitk::OpenGLRenderer*)(GetRenderer()))->GetVtkRenderer();
   //if(vtkrenderer!=NULL) vtkrenderer->ResetCamera();
   //vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkSliceWidget::UpdateGL()
 {
   GetRenderer()->GetDisplayGeometry()->Fit();
   mitk::RenderingManager::GetInstance()->RequestUpdate(
       GetRenderer()->GetRenderWindow());
 }
 
 void QmitkSliceWidget::mousePressEvent(QMouseEvent * e)
 {
   if (e->button() == Qt::RightButton && popUpEnabled)
   {
     popUp->popup(QCursor::pos());
   }
 }
 
 void QmitkSliceWidget::wheelEvent(QWheelEvent * e)
 {
   int val = m_NavigatorWidget->GetPos();
 
   if (e->orientation() * e->delta() > 0)
   {
     m_NavigatorWidget->SetPos(val + 1);
   }
   else
   {
     if (val > 0)
       m_NavigatorWidget->SetPos(val - 1);
   }
 }
 
 void QmitkSliceWidget::ChangeView(QAction* val)
 {
   if (val->text() == "Axial")
   {
     InitWidget(mitk::SliceNavigationController::Axial);
   }
   else if (val->text() == "Frontal")
   {
     InitWidget(mitk::SliceNavigationController::Frontal);
   }
   else if (val->text() == "Sagittal")
   {
     InitWidget(mitk::SliceNavigationController::Sagittal);
   }
 }
 
 void QmitkSliceWidget::setPopUpEnabled(bool b)
 {
   popUpEnabled = b;
 }
 
 QmitkSliderNavigatorWidget* QmitkSliceWidget::GetNavigatorWidget()
 {
   return m_NavigatorWidget;
 }
 
 void QmitkSliceWidget::SetLevelWindowEnabled(bool enable)
 {
   levelWindow->setEnabled(enable);
   if (!enable)
   {
     levelWindow->setMinimumWidth(0);
     levelWindow->setMaximumWidth(0);
   }
   else
   {
     levelWindow->setMinimumWidth(28);
     levelWindow->setMaximumWidth(28);
   }
 }
 
 bool QmitkSliceWidget::IsLevelWindowEnabled()
 {
   return levelWindow->isEnabled();
 }
 
 QmitkRenderWindow* QmitkSliceWidget::GetRenderWindow()
 {
   return m_RenderWindow;
 }
 
 mitk::SliceNavigationController*
 QmitkSliceWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 mitk::CameraRotationController*
 QmitkSliceWidget::GetCameraRotationController() const
 {
   return m_RenderWindow->GetCameraRotationController();
 }
 
 mitk::BaseController*
 QmitkSliceWidget::GetController() const
 {
   return m_RenderWindow->GetController();
 }
diff --git a/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp b/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp
index 81b5522b39..966032ed29 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp
@@ -1,65 +1,65 @@
 /*===================================================================
 
 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 "mitkContourModelToPointSetFilter.h"
 #include <mitkInteractionConst.h>
 #include <mitkPointOperation.h>
 
 
 mitk::ContourModelToPointSetFilter::ContourModelToPointSetFilter()
 {
   itk::DataObject::Pointer output = this->MakeOutput(0);
   this->SetNumberOfRequiredInputs(1);
   this->SetNumberOfRequiredOutputs( 1 );
   this->SetNthOutput(0, output.GetPointer());
 }
 mitk::ContourModelToPointSetFilter::~ContourModelToPointSetFilter()
 {
 
 }
 
 void mitk::ContourModelToPointSetFilter::GenerateData()
 {
 
   mitk::ContourModel::Pointer inputContour =  static_cast<mitk::ContourModel*>(this->GetInput(0));
   mitk::ContourModelToPointSetFilter::OutputType* outputPointSet = this->GetOutput();
 
   InputType::VertexIterator it = inputContour->IteratorBegin();
   InputType::VertexIterator end = inputContour->IteratorEnd();
   unsigned int pointId = 0;
 
 
   unsigned int timestep = inputContour->GetTimeSteps();
 
   for ( int i = 0; i < timestep; i++)
   {
 
 
     while ( it <= end )
     {
       mitk::Point3D p = (*it)->Coordinates;
       mitk::PointOperation popInsert( mitk::OpINSERT,
-                                      inputContour->GetTimeSlicedGeometry()->TimeStepToMS(timestep),
+                                      inputContour->GetTimeGeometry()->TimeStepToTimePoint(timestep),
                                       p,
                                       pointId++,
                                       false );
 
       outputPointSet->ExecuteOperation( &popInsert );
 
       it++;
     }
   }
 }
diff --git a/Modules/Segmentation/Algorithms/mitkContourUtils.cpp b/Modules/Segmentation/Algorithms/mitkContourUtils.cpp
index 630cd62dcc..96dacdb382 100644
--- a/Modules/Segmentation/Algorithms/mitkContourUtils.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourUtils.cpp
@@ -1,239 +1,237 @@
 /*===================================================================
 
 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 "mitkContourUtils.h"
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkInstantiateAccessFunctions.h"
 #include "ipSegmentation.h"
 
 #define InstantiateAccessFunction_ItkCopyFilledContourToSlice(pixelType, dim) \
   template void mitk::ContourUtils::ItkCopyFilledContourToSlice(itk::Image<pixelType,dim>*, const mitk::Image*, int);
 
 // explicitly instantiate the 2D version of this method
 InstantiateAccessFunctionForFixedDimension(ItkCopyFilledContourToSlice, 2);
 
 mitk::ContourUtils::ContourUtils()
 {
 }
 
 mitk::ContourUtils::~ContourUtils()
 {
 }
 
 
 mitk::ContourModel::Pointer mitk::ContourUtils::ProjectContourTo2DSlice(Image* slice, Contour* contourIn3D, bool itkNotUsed( correctionForIpSegmentation ), bool constrainToInside)
 {
   mitk::Contour::PointsContainerIterator it = contourIn3D->GetPoints()->Begin();
   mitk::Contour::PointsContainerIterator end = contourIn3D->GetPoints()->End();
 
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   while(it!=end)
   {
     contour->AddVertex(it.Value());
     it++;
   }
   return this->ProjectContourTo2DSlice(slice, contour, false/*not used*/, constrainToInside );
 }
 
 mitk::ContourModel::Pointer mitk::ContourUtils::ProjectContourTo2DSlice(Image* slice, ContourModel* contourIn3D, bool itkNotUsed( correctionForIpSegmentation ), bool constrainToInside)
 {
   if ( !slice || !contourIn3D ) return NULL;
 
   ContourModel::Pointer projectedContour = ContourModel::New();
   projectedContour->Initialize(*contourIn3D);
 
   const Geometry3D* sliceGeometry = slice->GetGeometry();
 
-  int numberOfTimesteps = contourIn3D->GetTimeSlicedGeometry()->GetTimeSteps();
+  int numberOfTimesteps = contourIn3D->GetTimeGeometry()->GetNumberOfTimeSteps();
 
   for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
   {
     ContourModel::VertexIterator iter = contourIn3D->Begin(currentTimestep);
     ContourModel::VertexIterator end = contourIn3D->End(currentTimestep);
 
     while( iter != end)
     {
       Point3D currentPointIn3D = (*iter)->Coordinates;
 
       Point3D projectedPointIn2D;
       projectedPointIn2D.Fill(0.0);
       sliceGeometry->WorldToIndex( currentPointIn3D, projectedPointIn2D );
       // MITK_INFO << "world point " << currentPointIn3D << " in index is " << projectedPointIn2D;
 
       if ( !sliceGeometry->IsIndexInside( projectedPointIn2D ) && constrainToInside )
       {
         MITK_INFO << "**" << currentPointIn3D << " is " << projectedPointIn2D << " --> correct it (TODO)" << std::endl;
       }
 
       projectedContour->AddVertex( projectedPointIn2D, currentTimestep );
       iter++;
     }
   }
 
   return projectedContour;
 }
 
 
 mitk::ContourModel::Pointer mitk::ContourUtils::BackProjectContourFrom2DSlice(const Geometry3D* sliceGeometry, Contour* contourIn2D, bool itkNotUsed( correctionForIpSegmentation ) )
 {
   mitk::Contour::PointsContainerIterator it = contourIn2D->GetPoints()->Begin();
   mitk::Contour::PointsContainerIterator end = contourIn2D->GetPoints()->End();
 
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   while(it!=end)
   {
     contour->AddVertex(it.Value());
     it++;
   }
   return this->BackProjectContourFrom2DSlice(sliceGeometry, contour, false/*not used*/);
 }
 
 mitk::ContourModel::Pointer mitk::ContourUtils::BackProjectContourFrom2DSlice(const Geometry3D* sliceGeometry, ContourModel* contourIn2D, bool itkNotUsed( correctionForIpSegmentation ) )
 {
   if ( !sliceGeometry || !contourIn2D ) return NULL;
 
   ContourModel::Pointer worldContour = ContourModel::New();
   worldContour->Initialize(*contourIn2D);
 
-  int numberOfTimesteps = contourIn2D->GetTimeSlicedGeometry()->GetTimeSteps();
+  int numberOfTimesteps = contourIn2D->GetTimeGeometry()->GetNumberOfTimeSteps();
 
   for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
   {
-
   ContourModel::VertexIterator iter = contourIn2D->Begin(currentTimestep);
   ContourModel::VertexIterator end = contourIn2D->End(currentTimestep);
 
   while( iter != end)
   {
     Point3D currentPointIn2D = (*iter)->Coordinates;
 
     Point3D worldPointIn3D;
     worldPointIn3D.Fill(0.0);
     sliceGeometry->IndexToWorld( currentPointIn2D, worldPointIn3D );
     //MITK_INFO << "index " << currentPointIn2D << " world " << worldPointIn3D << std::endl;
 
     worldContour->AddVertex( worldPointIn3D, currentTimestep );
     iter++;
   }
   }
 
   return worldContour;
 }
 
 
 
 void mitk::ContourUtils::FillContourInSlice( Contour* projectedContour, Image* sliceImage, int paintingPixelValue )
 {
   mitk::Contour::PointsContainerIterator it = projectedContour->GetPoints()->Begin();
   mitk::Contour::PointsContainerIterator end = projectedContour->GetPoints()->End();
 
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   while(it!=end)
   {
     contour->AddVertex(it.Value());
     it++;
   }
   this->FillContourInSlice(contour, sliceImage, paintingPixelValue);
 }
 
 
 void mitk::ContourUtils::FillContourInSlice( ContourModel* projectedContour, Image* sliceImage, int paintingPixelValue )
 {
   this->FillContourInSlice(projectedContour, 0, sliceImage, paintingPixelValue);
 }
 
 
 void mitk::ContourUtils::FillContourInSlice( ContourModel* projectedContour, unsigned int timeStep, Image* sliceImage, int paintingPixelValue )
 {
   // 1. Use ipSegmentation to draw a filled(!) contour into a new 8 bit 2D image, which will later be copied back to the slice.
   //    We don't work on the "real" working data, because ipSegmentation would restrict us to 8 bit images
 
   // convert the projected contour into a ipSegmentation format
   mitkIpInt4_t* picContour = new mitkIpInt4_t[2 * projectedContour->GetNumberOfVertices(timeStep)];
   unsigned int index(0);
   ContourModel::VertexIterator iter = projectedContour->Begin(timeStep);
   ContourModel::VertexIterator end = projectedContour->End(timeStep);
 
   while( iter != end)
   {
     picContour[ 2 * index + 0 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[0] + 1.0 ); // +0.5 wahrscheinlich richtiger
     picContour[ 2 * index + 1 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[1] + 1.0 );
     //MITK_INFO << "mitk 2d [" << (*iter)[0] << ", " << (*iter)[1] << "]  pic [" << picContour[ 2*index+0] << ", " << picContour[ 2*index+1] << "]";
     iter++;
     index++;
   }
 
   assert( sliceImage->GetSliceData() );
   mitkIpPicDescriptor* originalPicSlice = mitkIpPicNew();
   CastToIpPicDescriptor( sliceImage, originalPicSlice);
   mitkIpPicDescriptor* picSlice = ipMITKSegmentationNew( originalPicSlice );
   ipMITKSegmentationClear( picSlice );
 
   assert( originalPicSlice && picSlice );
 
   // here comes the actual contour filling algorithm (from ipSegmentation/Graphics Gems)
   ipMITKSegmentationCombineRegion ( picSlice, picContour, projectedContour->GetNumberOfVertices(timeStep), NULL, IPSEGMENTATION_OR,  1); // set to 1
 
   delete[] picContour;
 
   // 2. Copy the filled contour to the working data slice
   //    copy all pixels that are non-zero to the original image (not caring for the actual type of the working image). perhaps make the replace value a parameter ( -> general painting tool ).
   //    make the pic slice an mitk/itk image (as little ipPic code as possible), call a templated method with accessbyitk, iterate over the original and the modified slice
 
   Image::Pointer ipsegmentationModifiedSlice = Image::New();
   ipsegmentationModifiedSlice->Initialize( CastToImageDescriptor( picSlice ) );
   ipsegmentationModifiedSlice->SetSlice( picSlice->data );
 
   AccessFixedDimensionByItk_2( sliceImage, ItkCopyFilledContourToSlice, 2, ipsegmentationModifiedSlice, paintingPixelValue );
 
   ipsegmentationModifiedSlice = NULL; // free MITK header information
   ipMITKSegmentationFree( picSlice ); // free actual memory
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::ContourUtils::ItkCopyFilledContourToSlice( itk::Image<TPixel,VImageDimension>* originalSlice, const Image* filledContourSlice, int overwritevalue )
 {
   typedef itk::Image<TPixel,VImageDimension> SliceType;
 
   typename SliceType::Pointer filledContourSliceITK;
   CastToItkImage( filledContourSlice, filledContourSliceITK );
 
   // now the original slice and the ipSegmentation-painted slice are in the same format, and we can just copy all pixels that are non-zero
   typedef itk::ImageRegionIterator< SliceType >       OutputIteratorType;
   typedef itk::ImageRegionConstIterator< SliceType >   InputIteratorType;
 
   InputIteratorType inputIterator( filledContourSliceITK, filledContourSliceITK->GetLargestPossibleRegion() );
   OutputIteratorType outputIterator( originalSlice, originalSlice->GetLargestPossibleRegion() );
 
   outputIterator.GoToBegin();
   inputIterator.GoToBegin();
 
   while ( !outputIterator.IsAtEnd() )
   {
     if ( inputIterator.Get() != 0 )
     {
       outputIterator.Set( overwritevalue );
     }
 
     ++outputIterator;
     ++inputIterator;
   }
-}
-
+}
\ No newline at end of file
diff --git a/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
index 2c761588eb..b95a35f3bf 100644
--- a/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
+++ b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
@@ -1,516 +1,504 @@
 /*===================================================================
 
 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 "mitkCorrectorAlgorithm.h"
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageDataItem.h"
 #include "mitkContourUtils.h"
 
 mitk::CorrectorAlgorithm::CorrectorAlgorithm()
 :ImageToImageFilter()
 {
 }
 
 mitk::CorrectorAlgorithm::~CorrectorAlgorithm()
 {
 }
 
 
 void mitk::CorrectorAlgorithm::GenerateData()
 {
   Image::Pointer inputImage = const_cast<Image*>(ImageToImageFilter::GetInput(0));
 
   if (inputImage.IsNull() || inputImage->GetDimension() != 2)
   {
     itkExceptionMacro("CorrectorAlgorithm needs a 2D image as input.");
   }
 
   if (m_Contour.IsNull())
   {
     itkExceptionMacro("CorrectorAlgorithm needs a Contour object as input.");
   }
 
   // copy the input (since m_WorkingImage will be changed later)
   m_WorkingImage = inputImage;
 
-  TimeSlicedGeometry::Pointer originalGeometry;
+  TimeGeometry::Pointer originalGeometry = NULL;
 
-  if (inputImage->GetTimeSlicedGeometry() )
+  if (inputImage->GetTimeGeometry() )
   {
-    originalGeometry = inputImage->GetTimeSlicedGeometry()->Clone();
-    m_WorkingImage->SetGeometry( originalGeometry );
+    itk::LightObject::Pointer cloned = inputImage->GetTimeGeometry()->Clone();
+    originalGeometry = dynamic_cast<TimeGeometry *> (cloned.GetPointer());
+    m_WorkingImage->SetTimeGeometry( originalGeometry );
   }
   else
   {
     itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
   }
 
   Image::Pointer temporarySlice;
   // Convert to ipMITKSegmentationTYPE (because TobiasHeimannCorrectionAlgorithm relys on that data type)
   {
     itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
     CastToItkImage( m_WorkingImage, 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);
 
     temporarySlice = this->GetOutput();
     //  temporarySlice = ImportItkImage( correctPixelTypeImage );
     CastToMitkImage( correctPixelTypeImage, temporarySlice );
   }
 
 
   mitkIpPicDescriptor* temporarySlicePic = mitkIpPicNew();
   CastToIpPicDescriptor( temporarySlice, temporarySlicePic );
   TobiasHeimannCorrectionAlgorithm( temporarySlicePic );
 
-  temporarySlice->SetGeometry(originalGeometry);
-
-  // temporarySlice is our return value (user  can get it by calling GetOutput() )
-
-//  CalculateDifferenceImage( temporarySlice, inputImage );
-//  if ( m_DifferenceImage.IsNotNull() && inputImage->GetTimeSlicedGeometry() )
-//  {
-//    AffineGeometryFrame3D::Pointer originalGeometryAGF = inputImage->GetTimeSlicedGeometry()->Clone();
-//    TimeSlicedGeometry::Pointer originalGeometry = dynamic_cast<TimeSlicedGeometry*>( originalGeometryAGF.GetPointer() );
-//    m_DifferenceImage->SetGeometry( originalGeometry );
-//  }
-//  else
-//  {
-//    itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
-//  }
+  temporarySlice->SetTimeGeometry(originalGeometry);
+
 }
 
 void mitk::CorrectorAlgorithm::TobiasHeimannCorrectionAlgorithm(mitkIpPicDescriptor* pic)
 {
 /*!
 Some documentation (not by the original author)
 
 TobiasHeimannCorrectionAlgorithm will be called, when the user has finished drawing a freehand line.
 
 There should be different results, depending on the line's properties:
 
 1. Without any prior segmentation, the start point and the end point of the drawn line will be
 connected to a contour and the area enclosed by the contour will be marked as segmentation.
 
 2. When the whole line is inside a segmentation, start and end point will be connected to
 a contour and the area of this contour will be subtracted from the segmentation.
 
 3. When the line starts inside a segmentation and ends outside with only a single
 transition from segmentation to no-segmentation, nothing will happen.
 
 4. When there are multiple transitions between inside-segmentation and
 outside-segmentation, the line will be divided in so called segments. Each segment is
 either fully inside or fully outside a segmentation. When it is inside a segmentation, its
 enclosed area will be subtracted from the segmentation. When the segment is outside a
 segmentation, its enclosed area it will be added to the segmentation.
 
 The algorithm is described in full length in Tobias Heimann's diploma thesis
 (MBI Technical Report 145, p. 37 - 40).
 */
 
   int oaSize = 1000000; // if we need a fixed number, then let it be big
   int* _ofsArray = new int[ oaSize ];
   for (int i=0; i<oaSize; i++) _ofsArray[i] = 0;
 
   std::vector<TSegData> segData;
   segData.reserve( 16 );
 
 
   ContourUtils::Pointer contourUtils = ContourUtils::New();
   ContourModel::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice( m_WorkingImage, m_Contour, true, false );
 
   if (projectedContour.IsNull())
   {
     delete[] _ofsArray;
     return;
   }
 
   if (projectedContour->GetNumberOfVertices() < 2)
   {
     delete[] _ofsArray;
     return;
   }
 
   // convert the projected contour into a ipSegmentation format
   mitkIpInt4_t* _points = new mitkIpInt4_t[2 * projectedContour->GetNumberOfVertices()];
   ContourModel::VertexIterator iter = projectedContour->Begin();
   ContourModel::VertexIterator end = projectedContour->End();
   unsigned int index(0);
 
   while( iter != end)
   {
     _points[ 2 * index + 0 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[0] + 0.5 );
     _points[ 2 * index + 1 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[1] + 0.5 );
     ++index;
     iter++;
   }
 
   // store ofsets of the drawn line in array
   int _ofsNum = 0;
   unsigned int num = projectedContour->GetNumberOfVertices();
   int lastOfs = -1;
   for (unsigned int i=0; i<num-1; i++)
   {
     float x = _points [2*i] + 0.5;
     float y = _points [2*i+1] + 0.5;
     float difX = _points [2*i+2] - x + 0.5;
     float difY = _points [2*i+3] - y + 0.5;
     float length = sqrt( difX*difX + difY*difY );
     float dx = difX / length;
     float dy = difY / length;
     for (int p=0; ((float)p)<length; p++)
     {
       // if ofs is out of bounds, very nasty things will happen, so better check coordinates:
       if (x<0) x=0.5;
       else if (x>=pic->n[0]) x = pic->n[0]-0.5;
       if (y<0) y=0.5;
       else if (y>=pic->n[1]) y = pic->n[1]-0.5;
       // ok, now store safe ofs
       int ofs = (int)(x) + pic->n[0]*((int)(y));
       x += dx;
       y += dy;
       if (ofs != lastOfs)
       {
         _ofsArray[_ofsNum++] = ofs;
         lastOfs = ofs;
       }
     }
   }
 
   if (_ofsNum == 0)
   {
     // contour was completely outside the binary image
     delete[] _ofsArray;
     delete[] _points;
     return;
   }
 
   ipMITKSegmentationTYPE* picdata = static_cast<ipMITKSegmentationTYPE*>(pic->data);
 
   // divide line in logical segments:
   int numSegments = 0;
   ipMITKSegmentationTYPE state = *(picdata + _ofsArray[0]);
   int ofsP = 1;
   int modifyStart, modifyEnd;  // start of first and end of last segment
   bool nextSegment;
   segData.clear();
   do
   {
     nextSegment = false;
     while (ofsP<_ofsNum && *(picdata + _ofsArray[ofsP])==state) ofsP++;
     if (ofsP<_ofsNum)
     {
       int lineStart = ofsP-1;
       if (numSegments==0) modifyStart = ofsP;
       state = *(picdata + _ofsArray[ofsP]);
       while (ofsP<_ofsNum && *(picdata + _ofsArray[ofsP])==state) ofsP++;
       if (ofsP<_ofsNum)
       {
         int lineEnd = ofsP;
         modifyEnd = lineEnd;
         nextSegment = true;
         // now we've got a valid segment from lineStart to lineEnd
         TSegData thisSegData;
         thisSegData.lineStart = lineStart;
         thisSegData.lineEnd = lineEnd;
         thisSegData.modified = modifySegment( lineStart, lineEnd, state, pic, _ofsArray );
         segData.push_back( thisSegData );
         numSegments++;
       }
     }
   } while (nextSegment);
 
   for (int segNr=0; segNr < numSegments; segNr++)
   {
     // draw line if modified:
     if ( segData[segNr].modified )
     {
       for (int i=segData[segNr].lineStart+1; i<segData[segNr].lineEnd; i++)
       {
         *(picdata + _ofsArray[i]) = 1;
       }
     }
   }
 
   if (numSegments == 0)
   {
     if (num <= 1)
     { // only a single pixel. _ofsArray[_ofsNum-1] in else statement would crash, so don't do anything
       // no movement: delete operation
 
       // This behaviour would probably confuse users when they use the correction
       // tool to change a segmentation and it deletes much more than selected
 
       // if (state == 1)  ipMITKSegmentationReplaceRegion4N( pic, _ofsArray[0], 0 );
     }
     else if ( *(picdata + _ofsArray[_ofsNum-1]) == *(picdata + _ofsArray[0]))
     {
       // start point and end point both inside or both outside any segmentation
       // normal paint operation
       mitkIpInt4_t* p = new mitkIpInt4_t[2 * num];
       for (unsigned int i = 0; i < num; i++)
       {
         p[2 * i] = (mitkIpInt4_t) _points [2 * i];
         p[2 * i + 1] = (mitkIpInt4_t) _points [2 * i + 1];
       }
 
       if (state == 0) ipMITKSegmentationCombineRegion (pic, p, num, 0, IPSEGMENTATION_OR,  1);
       else            ipMITKSegmentationCombineRegion (pic, p, num, 0, IPSEGMENTATION_AND, 0);
 
       delete[] p;
     }
   }
 
   int numberOfContourPoints( 0 );
   int oneContourOffset( 0 );
   int newBufferSize( 0 );
 
   int imageSize = pic->n[0]*pic->n[1];
   for (oneContourOffset = 0; oneContourOffset < imageSize; oneContourOffset++)
     if ( ((ipMITKSegmentationTYPE*) pic->data)[oneContourOffset]> 0) break;
 
   float* contourPoints = ipMITKSegmentationGetContour8N( pic, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
 
   if (contourPoints)
   {
 
     // copy point from float* to mitk::ContourModel
     ContourModel::Pointer contourInImageIndexCoordinates = mitk::ContourModel::New();
     contourInImageIndexCoordinates->Initialize();
     Point3D newPoint;
     for (int index = 0; index < numberOfContourPoints; ++index)
     {
       newPoint[0] = contourPoints[ 2 * index + 0 ];
       newPoint[1] = contourPoints[ 2 * index + 1];
       newPoint[2] = 0;
 
       contourInImageIndexCoordinates->AddVertex( newPoint );
     }
 
     free(contourPoints);
 
     ContourUtils::Pointer contourUtils = ContourUtils::New();
     contourUtils->FillContourInSlice( contourInImageIndexCoordinates, m_WorkingImage );
   }
 
   delete[] _ofsArray;
   delete[] _points;
 }
 
 bool mitk::CorrectorAlgorithm::modifySegment( int lineStart, int lineEnd, ipMITKSegmentationTYPE state, mitkIpPicDescriptor *pic, int* _ofsArray )
 {
   // offsets for pixels right, top, left, bottom
   int nbDelta4[4];
   nbDelta4[0]=1;   nbDelta4[1]=pic->n[0];  nbDelta4[1]*=-1;  // necessary because of unsigned declaration of pic->n
   nbDelta4[2]=-1;  nbDelta4[3]=pic->n[0];
 
   // offsets for pixels right, top-right, top, top-left left, bottom-left, bottom, bottom-right
   int nbDelta8[8];
   nbDelta8[0] = 1;   nbDelta8[1] = nbDelta4[1]+1; nbDelta8[2] = nbDelta4[1];  nbDelta8[3] = nbDelta4[1]-1;
   nbDelta8[4] = -1;  nbDelta8[5] = nbDelta4[3]-1; nbDelta8[6] = nbDelta4[3];  nbDelta8[7] = nbDelta4[3]+1;
 
   ipMITKSegmentationTYPE* picdata = static_cast<ipMITKSegmentationTYPE*>(pic->data);
 
   ipMITKSegmentationTYPE saveStart = *(picdata + _ofsArray[lineStart]);
   ipMITKSegmentationTYPE saveEnd = *(picdata + _ofsArray[lineEnd]);
   ipMITKSegmentationTYPE newState = ((!state)&1) + 2; // probably equal to: ipMITKSegmentationTYPE newState = 3 - state;
 
   // make two copies of pic:
   mitkIpPicDescriptor *seg1 = mitkIpPicClone( pic );
   mitkIpPicDescriptor *seg2 = mitkIpPicClone( pic );
 
   int i;
 
   // mark line in original
   for (i=lineStart; i<=lineEnd; i++) {
     *(picdata + _ofsArray[i]) = 3;
   }
 
   // mark the first side in copy 1:
   bool firstPix = true;
   bool modified;
   int line = pic->n[0];                 // #pixels in line
   int maxOfs = (int)(line * pic->n[1]); // #pixels in slice
 
   for (i=lineStart+1; i<lineEnd; i++) {
     do {
       modified = false;
       for (int nb=0; nb<8; nb++) {
         int nbOfs = _ofsArray[i] + nbDelta8[nb];
         if (   nbOfs < 0        // above first line
             || nbOfs >= maxOfs   // below last line
            ) continue;
         ipMITKSegmentationTYPE nbVal = *(picdata + nbOfs);
         ipMITKSegmentationTYPE destVal = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
         if (nbVal!=3 && destVal!=newState) {  // get only neigbhours that are not part of the line itself
           if (firstPix) {
             *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState;  // this one is used to mark the side!
             firstPix = false;
             modified = true;
           }
           else {
             int tnb = 0;
             while (   tnb < 4
                    && ((nbOfs + nbDelta4[tnb]) >= 0) &&  ((nbOfs + nbDelta4[tnb]) < maxOfs)
                    && *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs + nbDelta4[tnb]) != newState
                   )
                   tnb++;
 
             if (tnb < 4 && ((nbOfs + nbDelta4[tnb]) >= 0) &&  ((nbOfs + nbDelta4[tnb]) < maxOfs) ) {
               *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState;  // we've got a buddy close
               modified = true;
             }
           }
         }
       }
     } while (modified);
   }
 
   // mark the other side in copy 2:
   for (i=lineStart+1; i<lineEnd; i++) {
     for (int nb=0; nb<4; nb++) {
       int nbOfs = _ofsArray[i] + nbDelta4[nb];
       if (   nbOfs < 0        // above first line
           || nbOfs >= maxOfs   // below last line
           ) continue;
       ipMITKSegmentationTYPE lineVal = *(picdata + nbOfs);
       ipMITKSegmentationTYPE side1Val = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
       if (lineVal != 3 && side1Val != newState) {
         *(((ipMITKSegmentationTYPE*)seg2->data) + nbOfs) = newState;
       }
     }
   }
 
   // take care of line ends for multiple segments:
   *(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineStart]) = newState;
   *(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineEnd]) = newState;
   *(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineStart]) = newState;
   *(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineEnd]) = newState;
 
 
   // replace regions:
   newState = (!state)&1;
   int sizeRegion1 = 0, sizeRegion2 = 0;
   for (i=lineStart+1; i<lineEnd; i++) {
     if (*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[i]) != newState) {
       sizeRegion1 += ipMITKSegmentationReplaceRegion4N( seg1, _ofsArray[i], newState );
     }
     if (*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[i]) != newState) {
       sizeRegion2 += ipMITKSegmentationReplaceRegion4N( seg2, _ofsArray[i], newState );
     }
   }
 
   // combine image:
   //printf( "Size Region1 = %8i      Size Region2 = %8i\n", sizeRegion1, sizeRegion2 );
   int sizeDif;
   ipMITKSegmentationTYPE *current, *segSrc;
   if (sizeRegion1 < sizeRegion2) {
     segSrc = (ipMITKSegmentationTYPE*)seg1->data;
     sizeDif = sizeRegion2 - sizeRegion1;
   }
   else {
     segSrc = (ipMITKSegmentationTYPE*)seg2->data;
     sizeDif = sizeRegion1 - sizeRegion2;
   }
 
   modified = false;
   if (sizeDif > 2*(lineEnd-lineStart)) {
     // decision is safe enough:
     ipMITKSegmentationTYPE *end = picdata + (pic->n[0]*pic->n[1]);
     for (current = picdata; current<end; current++) {
       if (*segSrc == newState) *current = newState;
       segSrc++;
     }
     modified = true;
   }
 
   // restore line:
   for (int i=lineStart+1; i<lineEnd; i++) {
     *(picdata + _ofsArray[i]) = state;
   }
   // restore end points:
   *(picdata + _ofsArray[lineStart]) = saveStart;
   *(picdata + _ofsArray[lineEnd]) = saveEnd;
 
   mitkIpPicFree( seg1 );
   mitkIpPicFree( seg2 );
 
   return modified;
 }
 
 void mitk::CorrectorAlgorithm::CalculateDifferenceImage( Image* modifiedImage, Image* originalImage )
 {
   /*
    * modifiedImage has ipMITKSegmentationTYPE
    * originalImage may be any type
    *
    * --> we calculate a diff image using ITK, switching for the correct type of originalImage
    */
   m_DifferenceImage = NULL;
   Image::Pointer tmpPtr = originalImage;
   AccessFixedDimensionByItk_1( tmpPtr, ItkCalculateDifferenceImage, 2, modifiedImage );
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::CorrectorAlgorithm::ItkCalculateDifferenceImage( itk::Image<TPixel, VImageDimension>* originalImage, Image* modifiedMITKImage )
 {
   typedef itk::Image<ipMITKSegmentationTYPE, VImageDimension>                     ModifiedImageType;
   typedef itk::Image<short signed int, VImageDimension>                           DiffImageType;
   typedef itk::ImageRegionConstIterator< itk::Image<TPixel,VImageDimension> >     OriginalSliceIteratorType;
   typedef itk::ImageRegionConstIterator< ModifiedImageType >                      ModifiedSliceIteratorType;
   typedef itk::ImageRegionIterator< DiffImageType >                               DiffSliceIteratorType;
 
   typename ModifiedImageType::Pointer modifiedImage;
   CastToItkImage( modifiedMITKImage, modifiedImage );
 
   // create new image as a copy of the input
   // this new image is the output of this filter class
   typename DiffImageType::Pointer diffImage;
   m_DifferenceImage = Image::New();
   PixelType pixelType( mitk::MakeScalarPixelType<short>() );
   m_DifferenceImage->Initialize( pixelType, 2, modifiedMITKImage->GetDimensions() );
   CastToItkImage( m_DifferenceImage, diffImage );
 
   // iterators over both input images (original and modified) and the output image (diff)
   ModifiedSliceIteratorType modifiedIterator( modifiedImage, diffImage->GetLargestPossibleRegion() );
   OriginalSliceIteratorType originalIterator( originalImage, diffImage->GetLargestPossibleRegion() );
   DiffSliceIteratorType         diffIterator( diffImage,     diffImage->GetLargestPossibleRegion() );
 
   modifiedIterator.GoToBegin();
   originalIterator.GoToBegin();
   diffIterator.GoToBegin();
 
   while ( !diffIterator.IsAtEnd() )
   {
     short signed int difference = static_cast<short signed int>( static_cast<signed int>(modifiedIterator.Get()) -
                                                           static_cast<signed int>(originalIterator.Get())); // not good for bigger values ?!
     diffIterator.Set( difference );
 
     ++modifiedIterator;
     ++originalIterator;
     ++diffIterator;
   }
 }
 
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
index 337463345f..e9b634877c 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
@@ -1,104 +1,104 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkDiffSliceOperation.h"
 
 #include <itkCommand.h>
 
 mitk::DiffSliceOperation::DiffSliceOperation():Operation(1)
 {
   m_TimeStep = 0;
   m_Slice = NULL;
   m_Image = NULL;
   m_WorldGeometry = NULL;
   m_SliceGeometry = NULL;
   m_ImageIsValid = false;
 }
 
 
 mitk::DiffSliceOperation::DiffSliceOperation(mitk::Image* imageVolume,
                                              vtkImageData* slice,
-                                             AffineGeometryFrame3D* sliceGeometry,
+                                             Geometry3D* sliceGeometry,
                                              unsigned int timestep,
-                                             AffineGeometryFrame3D* currentWorldGeometry):Operation(1)
+                                             Geometry3D* currentWorldGeometry):Operation(1)
 
 {
   m_WorldGeometry = currentWorldGeometry->Clone();
 
   /*
   Quick fix for bug 12338.
   Guard object - fix this when clone method of PlaneGeometry is cloning the reference geometry (see bug 13392)*/
   m_GuardReferenceGeometry = mitk::Geometry3D::New();
   m_GuardReferenceGeometry = dynamic_cast<mitk::Geometry2D*>(m_WorldGeometry.GetPointer())->GetReferenceGeometry();
   /*---------------------------------------------------------------------------------------------------*/
 
   m_SliceGeometry = sliceGeometry->Clone();
 
   m_TimeStep = timestep;
 
   /*m_zlibSliceContainer = CompressedImageContainer::New();
   m_zlibSliceContainer->SetImage( slice );*/
   m_Slice = vtkSmartPointer<vtkImageData>::New();
   m_Slice->DeepCopy(slice);
 
   m_Image = imageVolume;
 
   if ( m_Image) {
     /*add an observer to listen to the delete event of the image, this is necessary because the operation is then invalid*/
     itk::SimpleMemberCommand< DiffSliceOperation >::Pointer command = itk::SimpleMemberCommand< DiffSliceOperation >::New();
     command->SetCallbackFunction( this, &DiffSliceOperation::OnImageDeleted );
     //get the id of the observer, used to remove it later on
     m_DeleteObserverTag = imageVolume->AddObserver( itk::DeleteEvent(), command );
 
 
     m_ImageIsValid = true;
   }
   else
     m_ImageIsValid = false;
 
 }
 
 mitk::DiffSliceOperation::~DiffSliceOperation()
 {
 
   m_Slice = NULL;
   m_WorldGeometry = NULL;
   //m_zlibSliceContainer = NULL;
 
   if (m_ImageIsValid)
   {
     //if the image is still there, we have to remove the observer from it
     m_Image->RemoveObserver( m_DeleteObserverTag );
   }
   m_Image = NULL;
 }
 
 vtkImageData* mitk::DiffSliceOperation::GetSlice()
 {
   //Image::ConstPointer image = m_zlibSliceContainer->GetImage().GetPointer();
   return m_Slice;
 }
 
 bool mitk::DiffSliceOperation::IsValid()
 {
   return m_ImageIsValid && (m_Slice.GetPointer() != NULL) && (m_WorldGeometry.IsNotNull());//TODO improve
 }
 
 void mitk::DiffSliceOperation::OnImageDeleted()
 {
   //if our imageVolume is removed e.g. from the datastorage the operation is no lnger valid
   m_ImageIsValid = false;
 }
\ No newline at end of file
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h
index 4490eb8b58..35a02a166c 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h
@@ -1,119 +1,139 @@
 /*===================================================================
 
 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 mitkDiffSliceOperation_h_Included
 #define mitkDiffSliceOperation_h_Included
 
 #include "SegmentationExports.h"
 #include "mitkCommon.h"
 #include <mitkOperation.h>
 //#include "mitkCompressedImageContainer.h"
 
 #include <mitkImage.h>
 #include <vtkSmartPointer.h>
 #include <vtkImageData.h>
 
+//DEPRECATED
+#include <mitkTimeSlicedGeometry.h>
+
 
 namespace mitk
 {
   /** \brief An Operation for applying an edited slice to the volume.
     \sa DiffSliceOperationApplier
 
     The information for the operation is specified by properties:
 
      imageVolume            the volume where the slice was extracted from.
      slice                  the slice to be applied.
      timestep               the timestep in an 4D image.
      currentWorldGeometry   specifies the axis where the slice has to be applied in the volume.
 
     This Operation can be used to realize undo-redo functionality for e.g. segmentation purposes.
   */
   class Segmentation_EXPORT DiffSliceOperation : public Operation
   {
 
   public:
 
     mitkClassMacro(DiffSliceOperation, OperationActor);
 
     //itkNewMacro(DiffSliceOperation);
 
     //mitkNewMacro4Param(DiffSliceOperation,mitk::Image,mitk::Image,unsigned int, mitk::Geometry2D);
 
     /** \brief Creates an empty instance.
       Note that it is not valid yet. The properties of the object have to be set.
     */
     DiffSliceOperation();
 
     /** \brief */
-    DiffSliceOperation( mitk::Image* imageVolume, vtkImageData* slice, AffineGeometryFrame3D* sliceGeometry, unsigned int timestep, AffineGeometryFrame3D* currentWorldGeometry);
+    DiffSliceOperation( mitk::Image* imageVolume, vtkImageData* slice, Geometry3D* sliceGeometry, unsigned int timestep, Geometry3D* currentWorldGeometry);
+
+    /** \brief
+    *
+    * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
+    */
+    DEPRECATED(DiffSliceOperation( mitk::Image* imageVolume, vtkImageData* slice, TimeSlicedGeometry* sliceGeometry, unsigned int timestep, Geometry3D* currentWorldGeometry));
 
     /** \brief Check if it is a valid operation.*/
     bool IsValid();
 
     /** \brief Set the image volume.*/
     void SetImage(mitk::Image* image){ this->m_Image = image;}
     /** \brief Get th image volume.*/
     mitk::Image* GetImage(){return this->m_Image;}
 
     /** \brief Set thee slice to be applied.*/
     void SetImage(vtkImageData* slice){ this->m_Slice = slice;}
     /** \brief Get the slice that is applied in the operation.*/
     vtkImageData* GetSlice();
 
     /** \brief Get timeStep.*/
     void SetTimeStep(unsigned int timestep){this->m_TimeStep = timestep;}
     /** \brief Set timeStep*/
     unsigned int GetTimeStep(){return this->m_TimeStep;}
 
     /** \brief Set the axis where the slice has to be applied in the volume.*/
-    void SetSliceGeometry(AffineGeometryFrame3D* sliceGeometry){this->m_SliceGeometry = sliceGeometry;}
+    void SetSliceGeometry(Geometry3D* sliceGeometry){this->m_SliceGeometry = sliceGeometry;}
     /** \brief Get the axis where the slice has to be applied in the volume.*/
-    AffineGeometryFrame3D* GetSliceGeometry(){return this->m_SliceGeometry;}
+    Geometry3D* GetSliceGeometry(){return this->m_SliceGeometry;}
+
+
+    /** \brief Set the axis where the slice has to be applied in the volume.
+    * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
+    */
+    void SetSliceGeometry(TimeSlicedGeometry* sliceGeometry);
 
     /** \brief Set the axis where the slice has to be applied in the volume.*/
-    void SetCurrentWorldGeometry(AffineGeometryFrame3D* worldGeometry){this->m_WorldGeometry = worldGeometry;}
+    void SetCurrentWorldGeometry(Geometry3D* worldGeometry){this->m_WorldGeometry = worldGeometry;}
     /** \brief Get the axis where the slice has to be applied in the volume.*/
-    AffineGeometryFrame3D* GetWorldGeometry(){return this->m_WorldGeometry;}
+    Geometry3D* GetWorldGeometry(){return this->m_WorldGeometry;}
 
 
+    /** \brief Set the axis where the slice has to be applied in the volume.
+    * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
+    */
+    void SetCurrentWorldGeometry(TimeSlicedGeometry* worldGeometry);
+
   protected:
 
     virtual ~DiffSliceOperation();
 
     /** \brief Callback for image observer.*/
     void OnImageDeleted();
 
     //CompressedImageContainer::Pointer m_zlibSliceContainer;
 
     mitk::Image* m_Image;
 
     vtkSmartPointer<vtkImageData> m_Slice;
 
-    AffineGeometryFrame3D::Pointer m_SliceGeometry;
+    Geometry3D::Pointer m_SliceGeometry;
 
     unsigned int m_TimeStep;
 
-    AffineGeometryFrame3D::Pointer m_WorldGeometry;
+    Geometry3D::Pointer m_WorldGeometry;
 
     bool m_ImageIsValid;
 
     unsigned long m_DeleteObserverTag;
 
     mitk::Geometry3D::Pointer m_GuardReferenceGeometry;
 
   };
 }
 #endif
\ No newline at end of file
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
index 9d292ac3c1..4c5610dc1f 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
@@ -1,76 +1,76 @@
 /*===================================================================
 
 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 "mitkDiffSliceOperationApplier.h"
 #include "mitkRenderingManager.h"
 #include <vtkSmartPointer.h>
 
 mitk::DiffSliceOperationApplier::DiffSliceOperationApplier()
 {
 }
 
 mitk::DiffSliceOperationApplier::~DiffSliceOperationApplier()
 {
 }
 
 void mitk::DiffSliceOperationApplier::ExecuteOperation( Operation* operation )
 {
   DiffSliceOperation* imageOperation = dynamic_cast<DiffSliceOperation*>( operation );
 
   //as we only support DiffSliceOperation return if operation is not type of DiffSliceOperation
   if(!imageOperation)
     return;
 
 
   //chak if the operation is valid
   if(imageOperation->IsValid())
   {
     //the actual overwrite filter (vtk)
     vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
     //Set the slice as 'input'
     reslice->SetInputSlice(imageOperation->GetSlice());
 
     //set overwrite mode to true to write back to the image volume
     reslice->SetOverwriteMode(true);
     reslice->Modified();
 
     //a wrapper for vtkImageOverwrite
     mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
     extractor->SetInput( imageOperation->GetImage() );
     extractor->SetTimeStep( imageOperation->GetTimeStep() );
     extractor->SetWorldGeometry( dynamic_cast<Geometry2D*>(imageOperation->GetWorldGeometry()) );
     extractor->SetVtkOutputRequest(true);
-    extractor->SetResliceTransformByGeometry( imageOperation->GetImage()->GetTimeSlicedGeometry()->GetGeometry3D( imageOperation->GetTimeStep() ) );
+    extractor->SetResliceTransformByGeometry( imageOperation->GetImage()->GetGeometry( imageOperation->GetTimeStep() ) );
 
     extractor->Modified();
     extractor->Update();
 
     //make sure the modification is rendered
     RenderingManager::GetInstance()->RequestUpdateAll();
     imageOperation->GetImage()->Modified();
   }
 }
 
 //mitk::DiffSliceOperationApplier* mitk::DiffSliceOperationApplier::s_Instance = NULL;
 
 mitk::DiffSliceOperationApplier* mitk::DiffSliceOperationApplier::GetInstance()
 {
   //if(!s_Instance)
   static DiffSliceOperationApplier*  s_Instance = new DiffSliceOperationApplier();
 
   return s_Instance;
 }
\ No newline at end of file
diff --git a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
index 542f914b4e..27f699cb7b 100644
--- a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
+++ b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
@@ -1,532 +1,532 @@
 /*===================================================================
 
 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 "mitkShowSegmentationAsSmoothedSurface.h"
 #include "mitkImageToItk.h"
 #include "itkIntelligentBinaryClosingFilter.h"
 #include <mitkUIDGenerator.h>
 #include <mitkGeometry3D.h>
 #include <mitkProgressBar.h>
 #include <mitkStatusBar.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkImageToSurfaceFilter.h>
 #include <mitkVtkRepresentationProperty.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkRegionOfInterestImageFilter.h>
 #include <itkConstantPadImageFilter.h>
 #include <itkBinaryMedianImageFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkMultiplyImageFilter.h>
 #include <itkConnectedThresholdImageFilter.h>
 #include <itkAddImageFilter.h>
 #include <vtkQuadricDecimation.h>
 #include <vtkCleanPolyData.h>
 #include <vtkPolyDataNormals.h>
 
 using namespace mitk;
 using namespace std;
 
 ShowSegmentationAsSmoothedSurface::ShowSegmentationAsSmoothedSurface()
 {
 }
 
 ShowSegmentationAsSmoothedSurface::~ShowSegmentationAsSmoothedSurface()
 {
 }
 
 void ShowSegmentationAsSmoothedSurface::Initialize(const NonBlockingAlgorithm *other)
 {
   Superclass::Initialize(other);
 
   bool syncVisibility = false;
 
   if (other != NULL)
     other->GetParameter("Sync visibility", syncVisibility);
 
   SetParameter("Sync visibility", syncVisibility);
   SetParameter("Wireframe", false);
 
   // The Smoothing value is used as variance for a Gauß filter.
   // A reasonable default value equals the image spacing in mm.
   SetParameter("Smoothing", 1.0f);
 
   // Valid range for decimation value is [0, 1). High values
   // increase decimation, especially when very close to 1.
   // A value of 0 disables decimation.
   SetParameter("Decimation", 0.5f);
 
   // Valid range for closing value is [0, 1]. Higher values
   // increase closing. A value of 0 disables closing.
   SetParameter("Closing", 0.0f);
 }
 
 bool ShowSegmentationAsSmoothedSurface::ReadyToRun()
 {
   try
   {
     mitk::Image::Pointer image;
     GetPointerParameter("Input", image);
 
     return image.IsNotNull() && GetGroupNode();
   }
   catch (const invalid_argument &)
   {
     return false;
   }
 }
 
 bool ShowSegmentationAsSmoothedSurface::ThreadedUpdateFunction()
 {
   Image::Pointer image;
   GetPointerParameter("Input", image);
 
   float smoothing;
   GetParameter("Smoothing", smoothing);
 
   float decimation;
   GetParameter("Decimation", decimation);
 
   float closing;
   GetParameter("Closing", closing);
 
   int timeNr = 0;
   GetParameter("TimeNr", timeNr);
 
   if (image->GetDimension() == 4)
     MITK_INFO << "CREATING SMOOTHED POLYGON MODEL (t = " << timeNr << ')';
   else
     MITK_INFO << "CREATING SMOOTHED POLYGON MODEL";
 
   MITK_INFO << "  Smoothing  = " << smoothing;
   MITK_INFO << "  Decimation = " << decimation;
   MITK_INFO << "  Closing    = " << closing;
 
   Geometry3D::Pointer geometry = dynamic_cast<Geometry3D *>(image->GetGeometry()->Clone().GetPointer());
 
   // Make ITK image out of MITK image
 
   typedef itk::Image<unsigned char, 3> CharImageType;
   typedef itk::Image<unsigned short, 3> ShortImageType;
   typedef itk::Image<float, 3> FloatImageType;
 
   if (image->GetDimension() == 4)
   {
     ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
     imageTimeSelector->SetInput(image);
     imageTimeSelector->SetTimeNr(timeNr);
     imageTimeSelector->UpdateLargestPossibleRegion();
     image = imageTimeSelector->GetOutput(0);
   }
 
   ImageToItk<CharImageType>::Pointer imageToItkFilter = ImageToItk<CharImageType>::New();
 
   try
   {
     imageToItkFilter->SetInput(image);
   }
   catch (const itk::ExceptionObject &e)
   {
     // Most probably the input image type is wrong. Binary images are expected to be
     // >unsigned< char images.
     MITK_ERROR << e.GetDescription() << endl;
     return false;
   }
 
   imageToItkFilter->Update();
 
   CharImageType::Pointer itkImage = imageToItkFilter->GetOutput();
 
   // Get bounding box and relabel
 
   MITK_INFO << "Extracting VOI...";
 
   int imageLabel = 1;
   bool roiFound = false;
 
   CharImageType::IndexType minIndex;
   minIndex.Fill(numeric_limits<CharImageType::IndexValueType>::max());
 
   CharImageType::IndexType maxIndex;
   maxIndex.Fill(numeric_limits<CharImageType::IndexValueType>::min());
 
   itk::ImageRegionIteratorWithIndex<CharImageType> iter(itkImage, itkImage->GetLargestPossibleRegion());
 
   for (iter.GoToBegin(); !iter.IsAtEnd(); ++iter)
   {
     if (iter.Get() == imageLabel)
     {
       roiFound = true;
       iter.Set(1);
 
       CharImageType::IndexType currentIndex = iter.GetIndex();
 
       for (unsigned int dim = 0; dim < 3; ++dim)
       {
         minIndex[dim] = min(currentIndex[dim], minIndex[dim]);
         maxIndex[dim] = max(currentIndex[dim], maxIndex[dim]);
       }
     }
     else
     {
       iter.Set(0);
     }
   }
 
   if (!roiFound)
   {
     ProgressBar::GetInstance()->Progress(8);
     MITK_ERROR << "Didn't found segmentation labeled with " << imageLabel << "!" << endl;
     return false;
   }
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Extract and pad bounding box
 
   typedef itk::RegionOfInterestImageFilter<CharImageType, CharImageType> ROIFilterType;
 
   ROIFilterType::Pointer roiFilter = ROIFilterType::New();
   CharImageType::RegionType region;
   CharImageType::SizeType size;
 
   for (unsigned int dim = 0; dim < 3; ++dim)
   {
     size[dim] = maxIndex[dim] - minIndex[dim] + 1;
   }
 
   region.SetIndex(minIndex);
   region.SetSize(size);
 
   roiFilter->SetInput(itkImage);
   roiFilter->SetRegionOfInterest(region);
   roiFilter->ReleaseDataFlagOn();
   roiFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::ConstantPadImageFilter<CharImageType, CharImageType> PadFilterType;
 
   PadFilterType::Pointer padFilter = PadFilterType::New();
   const PadFilterType::SizeValueType pad[3] = { 10, 10, 10 };
 
   padFilter->SetInput(roiFilter->GetOutput());
   padFilter->SetConstant(0);
   padFilter->SetPadLowerBound(pad);
   padFilter->SetPadUpperBound(pad);
   padFilter->ReleaseDataFlagOn();
   padFilter->ReleaseDataBeforeUpdateFlagOn();
   padFilter->Update();
 
   CharImageType::Pointer roiImage = padFilter->GetOutput();
 
   roiImage->DisconnectPipeline();
   roiFilter = 0;
   padFilter = 0;
 
   // Correct origin of real geometry (changed by cropping and padding)
 
-  typedef AffineGeometryFrame3D::TransformType TransformType;
+  typedef Geometry3D::TransformType TransformType;
 
   TransformType::Pointer transform = TransformType::New();
   TransformType::OutputVectorType translation;
 
   for (unsigned int dim = 0; dim < 3; ++dim)
     translation[dim] = (int)minIndex[dim] - (int)pad[dim];
 
   transform->SetIdentity();
   transform->Translate(translation);
   geometry->Compose(transform, true);
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Median
 
   MITK_INFO << "Median...";
 
   typedef itk::BinaryMedianImageFilter<CharImageType, CharImageType> MedianFilterType;
 
   MedianFilterType::Pointer medianFilter = MedianFilterType::New();
   CharImageType::SizeType radius = { 0 };
 
   medianFilter->SetRadius(radius);
   medianFilter->SetBackgroundValue(0);
   medianFilter->SetForegroundValue(1);
   medianFilter->SetInput(roiImage);
   medianFilter->ReleaseDataFlagOn();
   medianFilter->ReleaseDataBeforeUpdateFlagOn();
   medianFilter->Update();
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Intelligent closing
 
   MITK_INFO << "Intelligent closing...";
 
   unsigned int surfaceRatio = (unsigned int)((1.0f - closing) * 100.0f);
 
   typedef itk::IntelligentBinaryClosingFilter<CharImageType, ShortImageType> ClosingFilterType;
 
   ClosingFilterType::Pointer closingFilter = ClosingFilterType::New();
 
   closingFilter->SetInput(medianFilter->GetOutput());
   closingFilter->ReleaseDataFlagOn();
   closingFilter->ReleaseDataBeforeUpdateFlagOn();
   closingFilter->SetSurfaceRatio(surfaceRatio);
   closingFilter->Update();
 
   ShortImageType::Pointer closedImage = closingFilter->GetOutput();
 
   closedImage->DisconnectPipeline();
   roiImage = 0;
   medianFilter = 0;
   closingFilter = 0;
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Gaussian blur
 
   MITK_INFO << "Gauss...";
 
   typedef itk::BinaryThresholdImageFilter<ShortImageType, FloatImageType> BinaryThresholdToFloatFilterType;
 
   BinaryThresholdToFloatFilterType::Pointer binThresToFloatFilter = BinaryThresholdToFloatFilterType::New();
 
   binThresToFloatFilter->SetInput(closedImage);
   binThresToFloatFilter->SetLowerThreshold(1);
   binThresToFloatFilter->SetUpperThreshold(1);
   binThresToFloatFilter->SetInsideValue(100);
   binThresToFloatFilter->SetOutsideValue(0);
   binThresToFloatFilter->ReleaseDataFlagOn();
   binThresToFloatFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::DiscreteGaussianImageFilter<FloatImageType, FloatImageType> GaussianFilterType;
 
   // From the following line on, IntelliSense (VS 2008) is broken. Any idea how to fix it?
   GaussianFilterType::Pointer gaussFilter = GaussianFilterType::New();
 
   gaussFilter->SetInput(binThresToFloatFilter->GetOutput());
   gaussFilter->SetUseImageSpacing(true);
   gaussFilter->SetVariance(smoothing);
   gaussFilter->ReleaseDataFlagOn();
   gaussFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> BinaryThresholdFromFloatFilterType;
 
   BinaryThresholdFromFloatFilterType::Pointer binThresFromFloatFilter = BinaryThresholdFromFloatFilterType::New();
 
   binThresFromFloatFilter->SetInput(gaussFilter->GetOutput());
   binThresFromFloatFilter->SetLowerThreshold(50);
   binThresFromFloatFilter->SetUpperThreshold(255);
   binThresFromFloatFilter->SetInsideValue(1);
   binThresFromFloatFilter->SetOutsideValue(0);
   binThresFromFloatFilter->ReleaseDataFlagOn();
   binThresFromFloatFilter->ReleaseDataBeforeUpdateFlagOn();
   binThresFromFloatFilter->Update();
 
   CharImageType::Pointer blurredImage = binThresFromFloatFilter->GetOutput();
 
   blurredImage->DisconnectPipeline();
   closedImage = 0;
   binThresToFloatFilter = 0;
   gaussFilter = 0;
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Fill holes
 
   MITK_INFO << "Filling cavities...";
 
   typedef itk::ConnectedThresholdImageFilter<CharImageType, CharImageType> ConnectedThresholdFilterType;
 
   ConnectedThresholdFilterType::Pointer connectedThresFilter = ConnectedThresholdFilterType::New();
 
   CharImageType::IndexType corner;
 
   corner[0] = 0;
   corner[1] = 0;
   corner[2] = 0;
 
   connectedThresFilter->SetInput(blurredImage);
   connectedThresFilter->SetSeed(corner);
   connectedThresFilter->SetLower(0);
   connectedThresFilter->SetUpper(0);
   connectedThresFilter->SetReplaceValue(2);
   connectedThresFilter->ReleaseDataFlagOn();
   connectedThresFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::BinaryThresholdImageFilter<CharImageType, CharImageType> BinaryThresholdFilterType;
 
   BinaryThresholdFilterType::Pointer binThresFilter = BinaryThresholdFilterType::New();
 
   binThresFilter->SetInput(connectedThresFilter->GetOutput());
   binThresFilter->SetLowerThreshold(0);
   binThresFilter->SetUpperThreshold(0);
   binThresFilter->SetInsideValue(50);
   binThresFilter->SetOutsideValue(0);
   binThresFilter->ReleaseDataFlagOn();
   binThresFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::AddImageFilter<CharImageType, CharImageType, CharImageType> AddFilterType;
 
   AddFilterType::Pointer addFilter = AddFilterType::New();
 
   addFilter->SetInput1(blurredImage);
   addFilter->SetInput2(binThresFilter->GetOutput());
   addFilter->ReleaseDataFlagOn();
   addFilter->ReleaseDataBeforeUpdateFlagOn();
   addFilter->Update();
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Surface extraction
 
   MITK_INFO << "Surface extraction...";
 
   Image::Pointer filteredImage = Image::New();
   CastToMitkImage(addFilter->GetOutput(), filteredImage);
 
   filteredImage->SetGeometry(geometry);
 
   ImageToSurfaceFilter::Pointer imageToSurfaceFilter = ImageToSurfaceFilter::New();
 
   imageToSurfaceFilter->SetInput(filteredImage);
   imageToSurfaceFilter->SetThreshold(50);
   imageToSurfaceFilter->SmoothOn();
   imageToSurfaceFilter->SetDecimate(ImageToSurfaceFilter::NoDecimation);
 
   m_Surface = imageToSurfaceFilter->GetOutput(0);
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Mesh decimation
 
   if (decimation > 0.0f && decimation < 1.0f)
   {
     MITK_INFO << "Quadric mesh decimation...";
 
     vtkQuadricDecimation *quadricDecimation = vtkQuadricDecimation::New();
     quadricDecimation->SetInput(m_Surface->GetVtkPolyData());
     quadricDecimation->SetTargetReduction(decimation);
     quadricDecimation->AttributeErrorMetricOn();
     quadricDecimation->GlobalWarningDisplayOff();
     quadricDecimation->Update();
 
     vtkCleanPolyData* cleaner = vtkCleanPolyData::New();
     cleaner->SetInput(quadricDecimation->GetOutput());
     cleaner->PieceInvariantOn();
     cleaner->ConvertLinesToPointsOn();
     cleaner->ConvertStripsToPolysOn();
     cleaner->PointMergingOn();
     cleaner->Update();
 
     m_Surface->SetVtkPolyData(cleaner->GetOutput());
   }
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Compute Normals
 
   vtkPolyDataNormals* computeNormals = vtkPolyDataNormals::New();
   computeNormals->SetInput(m_Surface->GetVtkPolyData());
   computeNormals->SetFeatureAngle(360.0f);
   computeNormals->FlipNormalsOff();
   computeNormals->Update();
 
   m_Surface->SetVtkPolyData(computeNormals->GetOutput());
 
   return true;
 }
 
 void ShowSegmentationAsSmoothedSurface::ThreadedUpdateSuccessful()
 {
   DataNode::Pointer node = LookForPointerTargetBelowGroupNode("Surface representation");
   bool addToTree = node.IsNull();
 
   if (addToTree)
   {
     node = DataNode::New();
 
     bool wireframe = false;
     GetParameter("Wireframe", wireframe);
 
     if (wireframe)
     {
       VtkRepresentationProperty *representation = dynamic_cast<VtkRepresentationProperty *>(
         node->GetProperty("material.representation"));
 
       if (representation != NULL)
         representation->SetRepresentationToWireframe();
     }
 
     node->SetProperty("opacity", FloatProperty::New(1.0));
     node->SetProperty("line width", IntProperty::New(1));
     node->SetProperty("scalar visibility", BoolProperty::New(false));
 
     UIDGenerator uidGenerator("Surface_");
     node->SetProperty("FILENAME", StringProperty::New(uidGenerator.GetUID() + ".vtk"));
 
     std::string groupNodeName = "surface";
     DataNode *groupNode = GetGroupNode();
 
     if (groupNode != NULL)
       groupNode->GetName(groupNodeName);
 
     node->SetProperty("name", StringProperty::New(groupNodeName));
   }
 
   node->SetData(m_Surface);
 
   if (addToTree)
   {
     DataNode* groupNode = GetGroupNode();
 
     if (groupNode != NULL)
     {
       groupNode->SetProperty("Surface representation", SmartPointerProperty::New(node));
 
       BaseProperty *colorProperty = groupNode->GetProperty("color");
 
       if (colorProperty != NULL)
         node->ReplaceProperty("color", colorProperty);
       else
         node->SetProperty("color", ColorProperty::New(1.0f, 0.0f, 0.0f));
 
       bool showResult = true;
       GetParameter("Show result", showResult);
 
       bool syncVisibility = false;
       GetParameter("Sync visibility", syncVisibility);
 
       Image::Pointer image;
       GetPointerParameter("Input", image);
 
       BaseProperty *organTypeProperty = image->GetProperty("organ type");
 
       if (organTypeProperty != NULL)
         m_Surface->SetProperty("organ type", organTypeProperty);
 
       BaseProperty *visibleProperty = groupNode->GetProperty("visible");
 
       if (visibleProperty != NULL && syncVisibility)
         node->ReplaceProperty("visible", visibleProperty);
       else
         node->SetProperty("visible", BoolProperty::New(showResult));
     }
 
     InsertBelowGroupNode(node);
   }
 
   Superclass::ThreadedUpdateSuccessful();
 }
diff --git a/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp b/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp
index 1e191bcdfa..e9cd3e882d 100644
--- a/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp
+++ b/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp
@@ -1,521 +1,520 @@
 /*===================================================================
 
 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 "mitkSegmentationInterpolationController.h"
 
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageTimeSelector.h"
 #include <mitkExtractSliceFilter.h>
 #include "mitkImageReadAccessor.h"
 //#include <mitkPlaneGeometry.h>
 
 #include "mitkShapeBasedInterpolationAlgorithm.h"
 
 #include <itkCommand.h>
 #include <itkImage.h>
 #include <itkImageSliceConstIteratorWithIndex.h>
 
 mitk::SegmentationInterpolationController::InterpolatorMapType mitk::SegmentationInterpolationController::s_InterpolatorForImage; // static member initialization
 
 mitk::SegmentationInterpolationController* mitk::SegmentationInterpolationController::InterpolatorForImage(const Image* image)
 {
   InterpolatorMapType::iterator iter = s_InterpolatorForImage.find( image );
   if ( iter != s_InterpolatorForImage.end() )
   {
     return iter->second;
   }
   else
   {
     return NULL;
   }
 }
 
 mitk::SegmentationInterpolationController::SegmentationInterpolationController()
 :m_BlockModified(false)
 {
 }
 
 void mitk::SegmentationInterpolationController::Activate2DInterpolation(bool status)
 {
   m_2DInterpolationActivated = status;
 }
 
 mitk::SegmentationInterpolationController::~SegmentationInterpolationController()
 {
   // remove this from the list of interpolators
   for ( InterpolatorMapType::iterator iter = s_InterpolatorForImage.begin();
         iter != s_InterpolatorForImage.end();
         ++iter )
   {
     if (iter->second == this)
     {
       s_InterpolatorForImage.erase( iter );
       break;
     }
   }
 }
 
 void mitk::SegmentationInterpolationController::OnImageModified(const itk::EventObject&)
 {
   if (!m_BlockModified  && m_Segmentation.IsNotNull() && m_2DInterpolationActivated )
   {
     SetSegmentationVolume( m_Segmentation );
   }
 }
 
 void mitk::SegmentationInterpolationController::BlockModified(bool block)
 {
   m_BlockModified = block;
 }
 
 void mitk::SegmentationInterpolationController::SetSegmentationVolume( const Image* segmentation )
 {
   // clear old information (remove all time steps
   m_SegmentationCountInSlice.clear();
 
   // delete this from the list of interpolators
   InterpolatorMapType::iterator iter = s_InterpolatorForImage.find( segmentation );
   if ( iter != s_InterpolatorForImage.end() )
   {
     s_InterpolatorForImage.erase( iter );
   }
 
   if (!segmentation) return;
   if (segmentation->GetDimension() > 4 || segmentation->GetDimension() < 3)
   {
     itkExceptionMacro("SegmentationInterpolationController needs a 3D-segmentation or 3D+t, not 2D.");
   }
 
   if (m_Segmentation != segmentation)
   {
     // observe Modified() event of image
     itk::ReceptorMemberCommand<SegmentationInterpolationController>::Pointer command = itk::ReceptorMemberCommand<SegmentationInterpolationController>::New();
     command->SetCallbackFunction( this, &SegmentationInterpolationController::OnImageModified );
     segmentation->AddObserver( itk::ModifiedEvent(), command );
   }
 
   m_Segmentation = segmentation;
 
   m_SegmentationCountInSlice.resize( m_Segmentation->GetTimeSteps() );
   for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
   {
     m_SegmentationCountInSlice[timeStep].resize(3);
     for (unsigned int dim = 0; dim < 3; ++dim)
     {
       m_SegmentationCountInSlice[timeStep][dim].clear();
       m_SegmentationCountInSlice[timeStep][dim].resize( m_Segmentation->GetDimension(dim) );
       m_SegmentationCountInSlice[timeStep][dim].assign( m_Segmentation->GetDimension(dim), 0 );
     }
   }
 
   s_InterpolatorForImage.insert( std::make_pair( m_Segmentation, this ) );
 
   // for all timesteps
   // scan whole image
   for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
   {
     ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
     timeSelector->SetInput( m_Segmentation );
     timeSelector->SetTimeNr( timeStep );
     timeSelector->UpdateLargestPossibleRegion();
     Image::Pointer segmentation3D = timeSelector->GetOutput();
     AccessFixedDimensionByItk_2( segmentation3D, ScanWholeVolume, 3, m_Segmentation, timeStep );
   }
 
   //PrintStatus();
 
   SetReferenceVolume( m_ReferenceImage );
 
   Modified();
 }
 
 void mitk::SegmentationInterpolationController::SetReferenceVolume( const Image* referenceImage )
 {
   m_ReferenceImage = referenceImage;
 
   if ( m_ReferenceImage.IsNull() ) return; // no image set - ignore it then
   assert ( m_Segmentation.IsNotNull() ); // should never happen
 
   // ensure the reference image has the same dimensionality and extents as the segmentation image
   if (    m_ReferenceImage.IsNull()
        || m_Segmentation.IsNull()
        || m_ReferenceImage->GetDimension() != m_Segmentation->GetDimension()
        || m_ReferenceImage->GetPixelType().GetNumberOfComponents() != 1
        || m_Segmentation->GetPixelType().GetNumberOfComponents() != 1
      )
   {
     MITK_WARN << "Segmentation image has different image characteristics than reference image." << std::endl;
     m_ReferenceImage = NULL;
     return;
   }
 
   for (unsigned int dim = 0; dim < m_Segmentation->GetDimension(); ++dim)
     if ( m_ReferenceImage->GetDimension(dim) != m_Segmentation->GetDimension(dim) )
     {
       MITK_WARN << "original patient image does not match segmentation (different extent in dimension " << dim
                 << "), ignoring patient image" << std::endl;
       m_ReferenceImage = NULL;
       return;
     }
 }
 
 void mitk::SegmentationInterpolationController::SetChangedVolume( const Image* sliceDiff, unsigned int timeStep )
 {
   if ( !sliceDiff ) return;
   if ( sliceDiff->GetDimension() != 3 ) return;
 
   AccessFixedDimensionByItk_1( sliceDiff, ScanChangedVolume, 3, timeStep );
 
   //PrintStatus();
   Modified();
 }
 
 
 void mitk::SegmentationInterpolationController::SetChangedSlice( const Image* sliceDiff, unsigned int sliceDimension, unsigned int sliceIndex, unsigned int timeStep )
 {
   if ( !sliceDiff ) return;
   if ( sliceDimension > 2 ) return;
   if ( timeStep >= m_SegmentationCountInSlice.size() ) return;
   if ( sliceIndex >= m_SegmentationCountInSlice[timeStep][sliceDimension].size() ) return;
 
   unsigned int dim0(0);
   unsigned int dim1(1);
 
   // determine the other two dimensions
   switch (sliceDimension)
   {
     default:
     case 2:
       dim0 = 0; dim1 = 1; break;
     case 1:
       dim0 = 0; dim1 = 2; break;
     case 0:
       dim0 = 1; dim1 = 2; break;
   }
 
   //mitkIpPicDescriptor* rawSlice = const_cast<Image*>(sliceDiff)->GetSliceData()->GetPicDescriptor(); // we promise not to change anything!
 
   mitk::ImageReadAccessor readAccess(const_cast<Image*>(sliceDiff));
   unsigned char* rawSlice = (unsigned char*) readAccess.GetData();
   if (!rawSlice) return;
 
   AccessFixedDimensionByItk_1( sliceDiff, ScanChangedSlice, 2, SetChangedSliceOptions(sliceDimension, sliceIndex, dim0, dim1, timeStep, rawSlice) );
 
   //PrintStatus();
 
   Modified();
 }
 
 template < typename DATATYPE >
 void mitk::SegmentationInterpolationController::ScanChangedSlice( itk::Image<DATATYPE, 2>*, const SetChangedSliceOptions& options )
 {
   DATATYPE* pixelData( (DATATYPE*)options.pixelData );
 
   unsigned int timeStep( options.timeStep );
 
   unsigned int sliceDimension( options.sliceDimension );
   unsigned int sliceIndex( options.sliceIndex );
 
   if ( sliceDimension > 2 ) return;
   if ( sliceIndex >= m_SegmentationCountInSlice[timeStep][sliceDimension].size() ) return;
 
   unsigned int dim0( options.dim0 );
   unsigned int dim1( options.dim1 );
 
   int numberOfPixels(0); // number of pixels in this slice that are not 0
 
   unsigned int dim0max = m_SegmentationCountInSlice[timeStep][dim0].size();
   unsigned int dim1max = m_SegmentationCountInSlice[timeStep][dim1].size();
 
   // scan the slice from two directions
   // and set the flags for the two dimensions of the slice
   for (unsigned int v = 0; v < dim1max; ++v)
   {
     for (unsigned int u = 0; u < dim0max; ++u)
     {
       DATATYPE value = *(pixelData + u + v * dim0max);
 
       assert ( (signed) m_SegmentationCountInSlice[timeStep][dim0][u] + (signed)value >= 0 ); // just for debugging. This must always be true, otherwise some counting is going wrong
       assert ( (signed) m_SegmentationCountInSlice[timeStep][dim1][v] + (signed)value >= 0 );
 
       m_SegmentationCountInSlice[timeStep][dim0][u] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][dim0][u] + value );
       m_SegmentationCountInSlice[timeStep][dim1][v] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][dim1][v] + value );
       numberOfPixels += static_cast<int>( value );
     }
   }
 
   // flag for the dimension of the slice itself
   assert ( (signed) m_SegmentationCountInSlice[timeStep][sliceDimension][sliceIndex] + numberOfPixels >= 0 );
   m_SegmentationCountInSlice[timeStep][sliceDimension][sliceIndex] += numberOfPixels;
 
   //MITK_INFO << "scan t=" << timeStep << " from (0,0) to (" << dim0max << "," << dim1max << ") (" << pixelData << "-" << pixelData+dim0max*dim1max-1 <<  ") in slice " << sliceIndex << " found " << numberOfPixels << " pixels" << std::endl;
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void mitk::SegmentationInterpolationController::ScanChangedVolume( itk::Image<TPixel, VImageDimension>* diffImage, unsigned int timeStep )
 {
   typedef itk::ImageSliceConstIteratorWithIndex< itk::Image<TPixel, VImageDimension> > IteratorType;
 
   IteratorType iter( diffImage, diffImage->GetLargestPossibleRegion() );
   iter.SetFirstDirection(0);
   iter.SetSecondDirection(1);
 
   int numberOfPixels(0); // number of pixels in this slice that are not 0
 
   typename IteratorType::IndexType index;
   unsigned int x = 0;
   unsigned int y = 0;
   unsigned int z = 0;
 
   iter.GoToBegin();
   while ( !iter.IsAtEnd() )
   {
     while ( !iter.IsAtEndOfSlice() )
     {
       while ( !iter.IsAtEndOfLine() )
       {
         index = iter.GetIndex();
 
         x = index[0];
         y = index[1];
         z = index[2];
 
         TPixel value = iter.Get();
 
         assert ( (signed) m_SegmentationCountInSlice[timeStep][0][x] + (signed)value >= 0 ); // just for debugging. This must always be true, otherwise some counting is going wrong
         assert ( (signed) m_SegmentationCountInSlice[timeStep][1][y] + (signed)value >= 0 );
 
         m_SegmentationCountInSlice[timeStep][0][x] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][0][x] + value );
         m_SegmentationCountInSlice[timeStep][1][y] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][1][y] + value );
 
         numberOfPixels += static_cast<int>( value );
 
         ++iter;
       }
       iter.NextLine();
     }
     assert ( (signed) m_SegmentationCountInSlice[timeStep][2][z] + numberOfPixels >= 0 );
     m_SegmentationCountInSlice[timeStep][2][z] += numberOfPixels;
     numberOfPixels = 0;
 
     iter.NextSlice();
   }
 }
 
 
 template < typename DATATYPE >
 void mitk::SegmentationInterpolationController::ScanWholeVolume( itk::Image<DATATYPE, 3>*, const Image* volume, unsigned int timeStep )
 {
   if (!volume) return;
   if ( timeStep >= m_SegmentationCountInSlice.size() ) return;
 
   for (unsigned int slice = 0; slice < volume->GetDimension(2); ++slice)
   {
     DATATYPE* rawVolume = static_cast<DATATYPE*>( const_cast<Image*>(volume)->GetVolumeData(timeStep)->GetData() ); // we again promise not to change anything, we'll just count
     //DATATYPE* rawSlice = static_cast<DATATYPE*>( volume->GetSliceData(slice)->GetData() ); // TODO THIS wouldn't work. Did I mess up with some internal mitk::Image data structure?
     DATATYPE* rawSlice = rawVolume + ( volume->GetDimension(0) * volume->GetDimension(1) * slice );
 
     ScanChangedSlice<DATATYPE>( NULL, SetChangedSliceOptions(2, slice, 0, 1, timeStep, rawSlice) );
   }
 }
 
 void mitk::SegmentationInterpolationController::PrintStatus()
 {
   unsigned int timeStep(0); // if needed, put a loop over time steps around everyting, but beware, output will be long
 
   MITK_INFO << "Interpolator status (timestep 0): dimensions "
            << m_SegmentationCountInSlice[timeStep][0].size() << " "
            << m_SegmentationCountInSlice[timeStep][1].size() << " "
            << m_SegmentationCountInSlice[timeStep][2].size() << std::endl;
 
   MITK_INFO << "Slice 0: " <<  m_SegmentationCountInSlice[timeStep][2][0] << std::endl;
 
   // row "x"
   for (unsigned int index = 0; index < m_SegmentationCountInSlice[timeStep][0].size(); ++index)
   {
     if ( m_SegmentationCountInSlice[timeStep][0][index] > 0 )
       MITK_INFO << "O";
     else
       MITK_INFO << ".";
   }
   MITK_INFO << std::endl;
 
   // rows "y" and "z" (diagonal)
   for (unsigned int index = 1; index < m_SegmentationCountInSlice[timeStep][1].size(); ++index)
   {
     if ( m_SegmentationCountInSlice[timeStep][1][index] > 0 )
       MITK_INFO << "O";
     else
       MITK_INFO << ".";
 
     if ( m_SegmentationCountInSlice[timeStep][2].size() > index ) // if we also have a z value here, then print it, too
     {
       for (unsigned int indent = 1; indent < index; ++indent)
         MITK_INFO << " ";
 
       if ( m_SegmentationCountInSlice[timeStep][2][index] > 0 )
         MITK_INFO << m_SegmentationCountInSlice[timeStep][2][index];//"O";
       else
         MITK_INFO << ".";
     }
 
     MITK_INFO << std::endl;
   }
 
   // z indices that are larger than the biggest y index
   for (unsigned int index = m_SegmentationCountInSlice[timeStep][1].size(); index < m_SegmentationCountInSlice[timeStep][2].size(); ++index)
   {
     for (unsigned int indent = 0; indent < index; ++indent)
     MITK_INFO << " ";
 
     if ( m_SegmentationCountInSlice[timeStep][2][index] > 0 )
       MITK_INFO << m_SegmentationCountInSlice[timeStep][2][index];//"O";
     else
       MITK_INFO << ".";
 
     MITK_INFO << std::endl;
   }
 }
 
 mitk::Image::Pointer mitk::SegmentationInterpolationController::Interpolate( unsigned int sliceDimension, unsigned int sliceIndex, const mitk::PlaneGeometry* currentPlane, unsigned int timeStep )
 {
   if (m_Segmentation.IsNull()) return NULL;
 
 
   if(!currentPlane)
   {
     return NULL;
   }
 
   if ( timeStep >= m_SegmentationCountInSlice.size() ) return NULL;
   if ( sliceDimension > 2 ) return NULL;
   unsigned int upperLimit = m_SegmentationCountInSlice[timeStep][sliceDimension].size();
   if ( sliceIndex >= upperLimit - 1 ) return NULL; // can't interpolate first and last slice
   if ( sliceIndex < 1  ) return NULL;
 
   if ( m_SegmentationCountInSlice[timeStep][sliceDimension][sliceIndex] > 0 ) return NULL; // slice contains a segmentation, won't interpolate anything then
 
   unsigned int lowerBound(0);
   unsigned int upperBound(0);
   bool bounds( false );
 
   for (lowerBound = sliceIndex - 1; /*lowerBound >= 0*/; --lowerBound)
   {
     if ( m_SegmentationCountInSlice[timeStep][sliceDimension][lowerBound] > 0 )
     {
       bounds = true;
       break;
     }
 
     if (lowerBound == 0) break; // otherwise overflow and start at something like 4294967295
   }
 
   if (!bounds) return NULL;
 
   bounds = false;
   for (upperBound = sliceIndex + 1 ; upperBound < upperLimit; ++upperBound)
   {
     if ( m_SegmentationCountInSlice[timeStep][sliceDimension][upperBound] > 0 )
     {
       bounds = true;
       break;
     }
   }
 
   if (!bounds) return NULL;
 
   // ok, we have found two neighboring slices with segmentations (and we made sure that the current slice does NOT contain anything
   //MITK_INFO << "Interpolate in timestep " << timeStep << ", dimension " << sliceDimension << ": estimate slice " << sliceIndex << " from slices " << lowerBound << " and " << upperBound << std::endl;
 
   mitk::Image::Pointer lowerMITKSlice;
   mitk::Image::Pointer upperMITKSlice;
   mitk::Image::Pointer resultImage;
 
   try
   {
     //Setting up the ExtractSliceFilter
     mitk::ExtractSliceFilter::Pointer extractor = ExtractSliceFilter::New();
     extractor->SetInput(m_Segmentation);
     extractor->SetTimeStep(timeStep);
-    extractor->SetResliceTransformByGeometry( m_Segmentation->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
+    extractor->SetResliceTransformByGeometry( m_Segmentation->GetTimeGeometry()->GetGeometryForTimeStep( timeStep ) );
     extractor->SetVtkOutputRequest(false);
 
     //Reslicing the current plane
     extractor->SetWorldGeometry(currentPlane);
     extractor->Modified();
     extractor->Update();
     resultImage = extractor->GetOutput();
     resultImage->DisconnectPipeline();
 
     //Creating PlaneGeometry for lower slice
     mitk::PlaneGeometry::Pointer reslicePlane = currentPlane->Clone();
 
     //Transforming the current origin so that it matches the lower slice
     mitk::Point3D origin = currentPlane->GetOrigin();
     m_Segmentation->GetSlicedGeometry()->WorldToIndex(origin, origin);
     origin[sliceDimension] = lowerBound;
     m_Segmentation->GetSlicedGeometry()->IndexToWorld(origin, origin);
     reslicePlane->SetOrigin(origin);
 
     //Extract the lower slice
     extractor->SetWorldGeometry(reslicePlane);
     extractor->Modified();
     extractor->Update();
     lowerMITKSlice = extractor->GetOutput();
     lowerMITKSlice->DisconnectPipeline();
 
     //Transforming the current origin so that it matches the upper slice
     m_Segmentation->GetSlicedGeometry()->WorldToIndex(origin, origin);
     origin[sliceDimension] = upperBound;
     m_Segmentation->GetSlicedGeometry()->IndexToWorld(origin, origin);
     reslicePlane->SetOrigin(origin);
 
     //Extract the upper slice
     extractor->SetWorldGeometry(reslicePlane);
     extractor->Modified();
     extractor->Update();
     upperMITKSlice = extractor->GetOutput();
     upperMITKSlice->DisconnectPipeline();
 
     if ( lowerMITKSlice.IsNull() || upperMITKSlice.IsNull() ) return NULL;
   }
   catch(const std::exception &e)
   {
     MITK_ERROR<<"Error in 2D interpolation: "<<e.what();
     return NULL;
   }
 
   // interpolation algorithm gets some inputs
   //   two segmentations (guaranteed to be of the same data type, but no special data type guaranteed)
   //   orientation (sliceDimension) of the segmentations
   //   position of the two slices (sliceIndices)
   //   one volume image (original patient image)
   //
   // interpolation algorithm can use e.g. itk::ImageSliceConstIteratorWithIndex to
   //   inspect the original patient image at appropriate positions
 
   mitk::SegmentationInterpolationAlgorithm::Pointer algorithm = mitk::ShapeBasedInterpolationAlgorithm::New().GetPointer();
   return algorithm->Interpolate( lowerMITKSlice.GetPointer(), lowerBound,
                                  upperMITKSlice.GetPointer(), upperBound,
                                  sliceIndex,
                                  sliceDimension,
                                  resultImage,
                                  timeStep,
                                  m_ReferenceImage );
-}
-
+}
\ No newline at end of file
diff --git a/Modules/Segmentation/DataManagement/mitkContour.cpp b/Modules/Segmentation/DataManagement/mitkContour.cpp
index 25de442b69..b381fb2909 100644
--- a/Modules/Segmentation/DataManagement/mitkContour.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContour.cpp
@@ -1,162 +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 "mitkContour.h"
+#include <mitkProportionalTimeGeometry.h>
 
 mitk::Contour::Contour() :
 m_ContourPath (PathType::New()),
 m_CurrentWindow ( NULL ),
 m_BoundingBox (BoundingBoxType::New()),
 m_Vertices ( BoundingBoxType::PointsContainer::New() ),
 m_Closed ( true ),
 m_Selected ( false ),
 m_Width (3.0)
 {
-  Superclass::InitializeTimeSlicedGeometry();
+  Superclass::InitializeTimeGeometry();
 }
 
 mitk::Contour::Contour( const Contour & other ): BaseData(other),
 m_ContourPath(other.m_ContourPath),
 m_CurrentWindow(other.m_CurrentWindow),
 m_BoundingBox(other.m_BoundingBox),
 m_Vertices(other.m_Vertices),
 m_Closed(other.m_Closed),
 m_Selected(other.m_Selected),
 m_Width(other.m_Width)
 {
 }
 
 mitk::Contour::~Contour()
 {
 }
 
 void mitk::Contour::AddVertex(mitk::Point3D newPoint)
 {
   BoundingBoxType::PointType p;
   p.CastFrom(newPoint);
   m_Vertices->InsertElement(m_Vertices->Size(), p);
   ContinuousIndexType idx;
   idx.CastFrom(newPoint);
   m_ContourPath->AddVertex(idx);
   m_BoundingBox->SetPoints(m_Vertices);
   Modified();
 }
 
 void mitk::Contour::UpdateOutputInformation()
 {
   // \todo probably we should do this additionally for each time-step
   float mitkBounds[6];
   if (m_Vertices->Size() == 0)  {
     mitkBounds[0] = 0.0;
     mitkBounds[1] = 0.0;
     mitkBounds[2] = 0.0;
     mitkBounds[3] = 0.0;
     mitkBounds[4] = 0.0;
     mitkBounds[5] = 0.0;
   }
   else
   {
     m_BoundingBox->ComputeBoundingBox();
     BoundingBoxType::BoundsArrayType tmp = m_BoundingBox->GetBounds();
     mitkBounds[0] = tmp[0];
     mitkBounds[1] = tmp[1];
     mitkBounds[2] = tmp[2];
     mitkBounds[3] = tmp[3];
     mitkBounds[4] = tmp[4];
     mitkBounds[5] = tmp[5];
   }
   Geometry3D* geometry3d = GetGeometry(0);
   geometry3d->SetBounds(mitkBounds);
-  GetTimeSlicedGeometry()->UpdateInformation();
+  GetTimeGeometry()->Update();
 }
 
 void mitk::Contour::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 bool mitk::Contour::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 bool mitk::Contour::VerifyRequestedRegion()
 {
   return true;
 }
 
 void mitk::Contour::SetRequestedRegion( const itk::DataObject*)
 {
 }
 
 mitk::Contour::PathType::Pointer mitk::Contour::GetContourPath() const
 {
   return m_ContourPath;
 }
 
 void mitk::Contour::SetCurrentWindow(vtkRenderWindow* rw)
 {
   m_CurrentWindow = rw;
 }
 
 vtkRenderWindow* mitk::Contour::GetCurrentWindow() const
 {
   return m_CurrentWindow;
 }
 
 void mitk::Contour::Initialize()
 {
   m_ContourPath = PathType::New();
   m_ContourPath->Initialize();
   m_BoundingBox = BoundingBoxType::New();
   m_Vertices = BoundingBoxType::PointsContainer::New();
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(1);
+  SetTimeGeometry(timeGeometry);
 }
 
 unsigned int mitk::Contour::GetNumberOfPoints() const
 {
   return m_Vertices->Size();
 }
 
 mitk::Contour::PointsContainerPointer
 mitk::Contour::GetPoints() const
 {
   return m_Vertices;
 }
 
 void mitk::Contour::SetPoints(mitk::Contour::PointsContainerPointer points)
 {
   m_Vertices = points;
   Modified();
 }
 
 void mitk::Contour::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 
   os << indent << "Number of verticies:  " << GetNumberOfPoints() << std::endl;
 
   mitk::Contour::PointsContainerIterator pointsIt = m_Vertices->Begin(), end = m_Vertices->End();
 
   os << indent << "Verticies:  " << std::endl;
 
   int i = 0;
   while ( pointsIt != end )
   {
     os << indent << indent << i << ": " << pointsIt.Value() << std::endl;
     ++pointsIt; ++i;
   }
 }
diff --git a/Modules/Segmentation/DataManagement/mitkContourModel.cpp b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
index 9fe3519768..5529937913 100644
--- a/Modules/Segmentation/DataManagement/mitkContourModel.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
@@ -1,639 +1,638 @@
 /*===================================================================
 
 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 <mitkContourModel.h>
 #include <mitkPlaneGeometry.h>
 
 mitk::ContourModel::ContourModel() :
   m_UpdateBoundingBox(true)
 {
   //set to initial state
   this->InitializeEmpty();
 }
 
 
 
 mitk::ContourModel::ContourModel(const mitk::ContourModel &other) :
 m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
 {
   m_SelectedVertex = NULL;
 }
 
 
 
 mitk::ContourModel::~ContourModel()
 {
   m_SelectedVertex = NULL;
   this->m_ContourSeries.clear();//TODO check destruction
 }
 
 
 
 void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep) )
   {
     this->AddVertex(vertex, false, timestep);
   }
 }
 
 
 
 void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertex(vertex, isControlPoint);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 
 void mitk::ContourModel::AddVertex(VertexType &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertex(vertex);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 
 void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep) )
   {
     this->AddVertexAtFront(vertex, false, timestep);
   }
 }
 
 
 
 void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertexAtFront(vertex, isControlPoint);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 
 void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertexAtFront(vertex);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 
 void mitk::ContourModel::InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(index > 0 && this->m_ContourSeries[timestep]->GetSize() > index)
     {
       this->m_ContourSeries[timestep]->InsertVertexAtIndex(vertex, isControlPoint, index);
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       this->Modified();this->m_UpdateBoundingBox = true;
     }
   }
 }
 
 
 bool mitk::ContourModel::IsEmpty( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IsEmpty();
   }
   return true;
 }
 
 
 int mitk::ContourModel::GetNumberOfVertices( int timestep) const
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->GetSize();
   }
   return -1;
 }
 
 
 
 const mitk::ContourModel::VertexType* mitk::ContourModel::GetVertexAt(int index, int timestep) const
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->GetVertexAt(index);
   }
   return NULL;
 }
 
 
 
 void mitk::ContourModel::Close( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->Close();
     this->InvokeEvent( ContourModelClosedEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 void mitk::ContourModel::Open( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->Open();
     this->InvokeEvent( ContourModelClosedEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 void mitk::ContourModel::SetIsClosed(bool isClosed, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->SetIsClosed(isClosed);
     this->InvokeEvent( ContourModelClosedEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 
 bool mitk::ContourModel::IsEmptyTimeStep( int t) const
 {
   return (t < 0) || (this->m_ContourSeries.size() <= t);
 }
 
 
 bool mitk::ContourModel::IsNearContour(mitk::Point3D &point, float eps, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
       return this->m_ContourSeries[timestep]->IsNearContour(point, eps);
   }
   return false;
 }
 
 void mitk::ContourModel::Concatenate(mitk::ContourModel* other, int timestep, bool check)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if( !this->m_ContourSeries[timestep]->IsClosed() )
     {
       this->m_ContourSeries[timestep]->Concatenate(other->m_ContourSeries[timestep], check);
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       this->Modified();this->m_UpdateBoundingBox = true;
     }
   }
 }
 
 
 
 mitk::ContourModel::VertexIterator mitk::ContourModel::Begin( int timestep)
 {
   return this->IteratorBegin(timestep);
 }
 
 
 
 mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IteratorBegin();
   }
   else
   {
     mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
   }
 }
 
 
 
 mitk::ContourModel::VertexIterator mitk::ContourModel::End( int timestep)
 {
   return this->IteratorEnd(timestep);
 }
 
 
 
 mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IteratorEnd();
   }
   else
   {
     mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
   }
 }
 
 
 
 bool mitk::ContourModel::IsClosed( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IsClosed();
   }
   return false;
 }
 
 bool mitk::ContourModel::SelectVertexAt(mitk::Point3D &point, float eps, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
   }
   return this->m_SelectedVertex != NULL;
 }
 
 
 bool mitk::ContourModel::SelectVertexAt(int index, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep) && index >= 0)
   {
     return (this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(index));
   }
   return false;
 }
 
 bool mitk::ContourModel::SetControlVertexAt(mitk::Point3D &point, float eps, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     VertexType* vertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
     if (vertex != NULL)
     {
         vertex->IsControlPoint = true;
         return true;
     }
   }
   return false;
 }
 
 bool mitk::ContourModel::SetControlVertexAt(int index, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep) && index >= 0)
   {
       VertexType* vertex = this->m_ContourSeries[timestep]->GetVertexAt(index);
       if (vertex != NULL)
       {
         vertex->IsControlPoint = true;
         return true;
      }
   }
   return false;
 }
 
 bool mitk::ContourModel::RemoveVertex(VertexType* vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(this->m_ContourSeries[timestep]->RemoveVertex(vertex))
     {
       this->Modified();this->m_UpdateBoundingBox = true;
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       return true;
     }
   }
   return false;
 }
 
 
 
 bool mitk::ContourModel::RemoveVertexAt(int index, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(this->m_ContourSeries[timestep]->RemoveVertexAt(index))
     {
       this->Modified();this->m_UpdateBoundingBox = true;
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       return true;
     }
   }
   return false;
 }
 
 
 
 bool mitk::ContourModel::RemoveVertexAt(mitk::Point3D &point, float eps, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(this->m_ContourSeries[timestep]->RemoveVertexAt(point, eps))
     {
       this->Modified();this->m_UpdateBoundingBox = true;
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       return true;
     }
   }
   return false;
 }
 
 
 
 void mitk::ContourModel::ShiftSelectedVertex(mitk::Vector3D &translate)
 {
   if(this->m_SelectedVertex)
   {
     this->ShiftVertex(this->m_SelectedVertex,translate);
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 
 void mitk::ContourModel::ShiftContour(mitk::Vector3D &translate, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     VertexListType* vList = this->m_ContourSeries[timestep]->GetVertexList();
     VertexIterator it = vList->begin();
     VertexIterator end = vList->end();
 
     //shift all vertices
     while(it != end)
     {
       this->ShiftVertex((*it),translate);
       it++;
     }
 
     this->Modified();this->m_UpdateBoundingBox = true;
     this->InvokeEvent( ContourModelShiftEvent() );
   }
 }
 
 
 
 void mitk::ContourModel::ShiftVertex(VertexType* vertex, mitk::Vector3D &vector)
 {
   vertex->Coordinates[0] += vector[0];
   vertex->Coordinates[1] += vector[1];
   vertex->Coordinates[2] += vector[2];
 }
 
 
 
 void mitk::ContourModel::Clear(int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     //clear data at timestep
     this->m_ContourSeries[timestep]->Clear();
     this->InitializeEmpty();
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 
 void mitk::ContourModel::Expand( int timeSteps )
 {
   int oldSize = this->m_ContourSeries.size();
 
   if( timeSteps > 0 && timeSteps > oldSize )
   {
     Superclass::Expand(timeSteps);
 
     //insert contours for each new timestep
     for( int i = oldSize; i < timeSteps; i++)
     {
       m_ContourSeries.push_back(mitk::ContourElement::New());
     }
 
     this->InvokeEvent( ContourModelExpandTimeBoundsEvent() );
   }
 }
 
 
 
 void mitk::ContourModel::SetRequestedRegionToLargestPossibleRegion ()
 {
   //no support for regions
 }
 
 
 
 bool mitk::ContourModel::RequestedRegionIsOutsideOfTheBufferedRegion ()
 {
   //no support for regions
   return false;
 }
 
 
 
 bool mitk::ContourModel::VerifyRequestedRegion ()
 {
   //no support for regions
   return true;
 }
 
 
 
 const mitk::Geometry3D * mitk::ContourModel::GetUpdatedGeometry (int t)
 {
   return Superclass::GetUpdatedGeometry(t);
 }
 
 
 
 mitk::Geometry3D* mitk::ContourModel::GetGeometry (int t)const
 {
   return Superclass::GetGeometry(t);
 }
 
 
 void mitk::ContourModel::SetRequestedRegion( const itk::DataObject *data)
 {
   //no support for regions
 }
 
 
 void mitk::ContourModel::Clear()
 {
   //clear data and set to initial state again
   this->ClearData();
   this->InitializeEmpty();
   this->Modified();this->m_UpdateBoundingBox = true;
 }
 
 
 void mitk::ContourModel::RedistributeControlVertices(int period, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->RedistributeControlVertices(this->GetSelectedVertex(), period);
     this->InvokeEvent( ContourModelClosedEvent() );
     this->Modified();this->m_UpdateBoundingBox = true;
   }
 }
 
 
 void mitk::ContourModel::ClearData()
 {
   //call the superclass, this releases the data of BaseData
   Superclass::ClearData();
 
   //clear out the time resolved contours
   this->m_ContourSeries.clear();
 }
 
 
 
 void mitk::ContourModel::Initialize()
 {
   this->InitializeEmpty();
   this->Modified();this->m_UpdateBoundingBox = true;
 }
 
 
 
 void mitk::ContourModel::Initialize(mitk::ContourModel &other)
 {
-  unsigned int numberOfTimesteps = other.GetTimeSlicedGeometry()->GetTimeSteps();
+  unsigned int numberOfTimesteps = other.GetTimeGeometry()->GetNumberOfTimeSteps();
   this->InitializeTimeSlicedGeometry(numberOfTimesteps);
 
   for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
   {
     this->m_ContourSeries.push_back(mitk::ContourElement::New());
     this->SetIsClosed(other.IsClosed(currentTimestep),currentTimestep);
   }
 
   m_SelectedVertex = NULL;
   this->m_lineInterpolation = other.m_lineInterpolation;
   this->Modified();this->m_UpdateBoundingBox = true;
 }
 
 
 
 void mitk::ContourModel::InitializeEmpty()
 {
   //clear data at timesteps
   this->m_ContourSeries.resize(0);
   this->m_ContourSeries.push_back(mitk::ContourElement::New());
 
   //set number of timesteps to one
-  this->InitializeTimeSlicedGeometry(1);
+  this->InitializeTimeGeometry(1);
 
   m_SelectedVertex = NULL;
   this->m_lineInterpolation = ContourModel::LINEAR;
 }
 
 
 void mitk::ContourModel::UpdateOutputInformation()
 {
   if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
 
   if(this->m_UpdateBoundingBox)
   {
-
     //update the bounds of the geometry according to the stored vertices
     float mitkBounds[6];
 
     //calculate the boundingbox at each timestep
     typedef itk::BoundingBox<unsigned long, 3, ScalarType>        BoundingBoxType;
     typedef BoundingBoxType::PointsContainer                      PointsContainer;
 
     int timesteps = this->GetTimeSteps();
 
     //iterate over the timesteps
     for(int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
     {
       if( dynamic_cast< mitk::PlaneGeometry* >(this->GetGeometry(currenTimeStep)) )
       {
         //do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
         return;
       }
       else
       {//we have a 3D geometry -> let's update bounds
         //only update bounds if the contour was modified
         if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
         {
           mitkBounds[0] = 0.0;
           mitkBounds[1] = 0.0;
           mitkBounds[2] = 0.0;
           mitkBounds[3] = 0.0;
           mitkBounds[4] = 0.0;
           mitkBounds[5] = 0.0;
 
           BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
 
           PointsContainer::Pointer points = PointsContainer::New();
 
           VertexIterator it = this->IteratorBegin(currenTimeStep);
           VertexIterator end = this->IteratorEnd(currenTimeStep);
 
           //fill the boundingbox with the points
           while(it != end)
           {
             Point3D currentP = (*it)->Coordinates;
             BoundingBoxType::PointType p;
             p.CastFrom(currentP);
             points->InsertElement(points->Size(), p);
 
             it++;
           }
 
           //construct the new boundingBox
           boundingBox->SetPoints(points);
           boundingBox->ComputeBoundingBox();
           BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
           mitkBounds[0] = tmp[0];
           mitkBounds[1] = tmp[1];
           mitkBounds[2] = tmp[2];
           mitkBounds[3] = tmp[3];
           mitkBounds[4] = tmp[4];
           mitkBounds[5] = tmp[5];
 
           //set boundingBox at current timestep
           Geometry3D* geometry3d = this->GetGeometry(currenTimeStep);
           geometry3d->SetBounds(mitkBounds);
         }
       }
     }
     this->m_UpdateBoundingBox = false;
   }
-  GetTimeSlicedGeometry()->UpdateInformation();
+  GetTimeGeometry()->Update();
 }
 
 
 void mitk::ContourModel::ExecuteOperation(mitk::Operation* operation)
 {
   //not supported yet
-}
+}
\ No newline at end of file
diff --git a/Modules/Segmentation/DataManagement/mitkContourModel.h b/Modules/Segmentation/DataManagement/mitkContourModel.h
index 5418a270ff..035c7e7427 100644
--- a/Modules/Segmentation/DataManagement/mitkContourModel.h
+++ b/Modules/Segmentation/DataManagement/mitkContourModel.h
@@ -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.
 
 ===================================================================*/
 #ifndef _MITK_CONTOURMODEL_H_
 #define _MITK_CONTOURMODEL_H_
 
 #include "mitkCommon.h"
 #include "SegmentationExports.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 Segmentation_EXPORT ContourModel : public BaseData
   {
 
   public:
 
     mitkClassMacro(ContourModel, BaseData);
 
     itkNewMacro(Self);
 
     mitkCloneMacro(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 TimeSlicedGeometry will not be expanded.
+    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 TimeSlicedGeometry will not be expanded.
+    will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertex(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 TimeSlicedGeometry will not be expanded.
+    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 TimeSlicedGeometry will not be expanded.
+    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 TimeSlicedGeometry will not be expanded.
+    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 TimeSlicedGeometry will not be expanded.
+    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 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 isClosed 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 SetIsClosed(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
     */
     bool IsEmpty( int timestep=0);
 
     /** \brief Returns the vertex at the index position within the container.
     */
     virtual const VertexType* GetVertexAt(int index, int timestep=0) const;
 
     /** \brief Check if there isn't something at this timestep.
     */
     virtual bool IsEmptyTimeStep( 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(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::Geometry3D* GetUpdatedGeometry (int t=0);
 
     /**
     \brief Get the Geometry3D for timestep t.
     */
     virtual mitk::Geometry3D* 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 TimeSlicedGeometry to given number of timesteps.
+    \brief Expand the timebounds of the TimeGeometry to given number of timesteps.
     */
     virtual void Expand( 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:
 
     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/Segmentation/DataManagement/mitkContourSet.cpp b/Modules/Segmentation/DataManagement/mitkContourSet.cpp
index abdc16569e..a6a0820249 100644
--- a/Modules/Segmentation/DataManagement/mitkContourSet.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourSet.cpp
@@ -1,121 +1,129 @@
 /*===================================================================
 
 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 "mitkContourSet.h"
+#include <mitkProportionalTimeGeometry.h>
 
 mitk::ContourSet::ContourSet() :
   m_ContourVector( ContourVectorType() ),
   m_NumberOfContours (0)
 {
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(1);
+  SetTimeGeometry(timeGeometry);
 }
 
 mitk::ContourSet::~ContourSet()
 {
 }
 
 void mitk::ContourSet::AddContour(unsigned int index, mitk::Contour::Pointer contour)
 {
   m_ContourVector.insert(std::make_pair( index , contour) );
 }
 
 
 void mitk::ContourSet::RemoveContour(unsigned long index)
 {
   m_ContourVector.erase( index );
 }
 
 void mitk::ContourSet::UpdateOutputInformation()
 {
   mitk::ContourSet::ContourVectorType contourVec = GetContours();
   mitk::ContourSet::ContourIterator contoursIterator = contourVec.begin();
   mitk::ContourSet::ContourIterator contoursIteratorEnd = contourVec.end();
 
   // initialize container
   mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
 
   mitk::BoundingBox::PointIdentifier pointid=0;
   mitk::Point3D point;
 
-  mitk::AffineTransform3D* transform = GetTimeSlicedGeometry()->GetIndexToWorldTransform();
+  mitk::AffineTransform3D* transform = GetGeometry(0)->GetIndexToWorldTransform();
   mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
   transform->GetInverse(inverse);
 
   // calculate a bounding box that includes all contours
   // \todo probably we should do this additionally for each time-step
   while (contoursIterator != contoursIteratorEnd)
   {
-    const Geometry3D* geometry = (*contoursIterator).second->GetUpdatedTimeSlicedGeometry();
+    const TimeGeometry* geometry = (*contoursIterator).second->GetUpdatedTimeGeometry();
     unsigned char i;
     for(i=0; i<8; ++i)
     {
-      point = inverse->TransformPoint(geometry->GetCornerPoint(i));
+      point = inverse->TransformPoint(geometry->GetCornerPointInWorld(i));
       if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < mitk::large)
         pointscontainer->InsertElement( pointid++, point);
       else
       {
         itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. BoundingObject: " << (*contoursIterator).second );
       }
     }
     ++contoursIterator;
   }
 
   mitk::BoundingBox::Pointer boundingBox = mitk::BoundingBox::New();
   boundingBox->SetPoints(pointscontainer);
   boundingBox->ComputeBoundingBox();
 
   Geometry3D* geometry3d = GetGeometry(0);
   geometry3d->SetIndexToWorldTransform(transform);
   geometry3d->SetBounds(boundingBox->GetBounds());
 
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry3d, GetTimeSlicedGeometry()->GetTimeSteps());
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(geometry3d,GetTimeGeometry()->GetNumberOfTimeSteps());
+  SetTimeGeometry(timeGeometry);
+
 }
 
 void mitk::ContourSet::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 bool mitk::ContourSet::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return true;
 }
 
 bool mitk::ContourSet::VerifyRequestedRegion()
 {
     return true;
 }
 
 void mitk::ContourSet::SetRequestedRegion( const itk::DataObject*)
 {
 }
 
 void mitk::ContourSet::Initialize()
 {
   m_ContourVector = ContourVectorType();
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(1);
+  SetTimeGeometry(timeGeometry);
 }
 
 
 unsigned int mitk::ContourSet::GetNumberOfContours()
 {
   return m_ContourVector.size();
 }
 
 mitk::ContourSet::ContourVectorType mitk::ContourSet::GetContours()
 {
   return m_ContourVector;
 }
diff --git a/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp b/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
index 700ac11a19..585b57aa88 100644
--- a/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
+++ b/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
@@ -1,368 +1,374 @@
 /*===================================================================
 
 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 "mitkExtrudedContour.h"
 #include "mitkVector.h"
 #include "mitkBaseProcess.h"
+#include "mitkProportionalTimeGeometry.h"
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkPlanes.h>
 #include <vtkClipPolyData.h>
 
 #include <vtkPolygon.h>
 #include <vtkFloatArray.h>
 #include <vtkDoubleArray.h>
 #include <vtkPlane.h>
 
 
 //vtkButterflySubdivisionFilter * subdivs;
 #include <vtkSampleFunction.h>
 #include <vtkTriangleFilter.h>
 #include <vtkLinearSubdivisionFilter.h>
 #include <vtkImageData.h>
 #include <vtkCubeSource.h>
 
 mitk::ExtrudedContour::ExtrudedContour()
   : m_Contour(NULL), m_ClippingGeometry(NULL), m_AutomaticVectorGeneration(false)
 {
-  GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(1);
+  SetTimeGeometry(timeGeometry);
 
   FillVector3D(m_Vector, 0.0, 0.0, 1.0);
   m_RightVector.Fill(0.0);
 
   m_ExtrusionFilter = vtkLinearExtrusionFilter::New();
 
   m_ExtrusionFilter->CappingOff();
   m_ExtrusionFilter->SetExtrusionTypeToVectorExtrusion();
 
   double vtkvector[3]={0,0,1};
 
   // set extrusion vector
   m_ExtrusionFilter->SetVector(vtkvector);
 
   m_TriangleFilter = vtkTriangleFilter::New();
   m_TriangleFilter->SetInput(m_ExtrusionFilter->GetOutput());
 
   m_SubdivisionFilter = vtkLinearSubdivisionFilter::New();
   m_SubdivisionFilter->SetInput(m_TriangleFilter->GetOutput());
   m_SubdivisionFilter->SetNumberOfSubdivisions(4);
 
   m_ClippingBox = vtkPlanes::New();
   m_ClipPolyDataFilter = vtkClipPolyData::New();
   m_ClipPolyDataFilter->SetInput(m_SubdivisionFilter->GetOutput());
   m_ClipPolyDataFilter->SetClipFunction(m_ClippingBox);
   m_ClipPolyDataFilter->InsideOutOn();
 
   m_Polygon = vtkPolygon::New();
 
   m_ProjectionPlane = mitk::PlaneGeometry::New();
 }
 
 mitk::ExtrudedContour::~ExtrudedContour()
 {
   m_ClipPolyDataFilter->Delete();
   m_ClippingBox->Delete();
   m_SubdivisionFilter->Delete();
   m_TriangleFilter->Delete();
   m_ExtrusionFilter->Delete();
   m_Polygon->Delete();
 }
 
 bool mitk::ExtrudedContour::IsInside(const Point3D& worldPoint) const
 {
   static double polygonNormal[3]={0.0,0.0,1.0};
 
   // project point onto plane
   float xt[3];
   itk2vtk(worldPoint, xt);
 
   xt[0] = worldPoint[0]-m_Origin[0];
   xt[1] = worldPoint[1]-m_Origin[1];
   xt[2] = worldPoint[2]-m_Origin[2];
 
   float dist=xt[0]*m_Normal[0]+xt[1]*m_Normal[1]+xt[2]*m_Normal[2];
   xt[0] -= dist*m_Normal[0];
   xt[1] -= dist*m_Normal[1];
   xt[2] -= dist*m_Normal[2];
 
   double x[3];
 
   x[0] = xt[0]*m_Right[0]+xt[1]*m_Right[1]+xt[2]*m_Right[2];
   x[1] = xt[0]*m_Down[0] +xt[1]*m_Down[1] +xt[2]*m_Down[2];
   x[2] = 0;
 
   // determine whether it's in the selection loop and then evaluate point
   // in polygon only if absolutely necessary.
   if ( x[0] >= this->m_ProjectedContourBounds[0] && x[0] <= this->m_ProjectedContourBounds[1] &&
     x[1] >= this->m_ProjectedContourBounds[2] && x[1] <= this->m_ProjectedContourBounds[3] &&
     this->m_Polygon->PointInPolygon(x, m_Polygon->Points->GetNumberOfPoints(),
     ((vtkDoubleArray *)this->m_Polygon->Points->GetData())->GetPointer(0),
     (double*)const_cast<mitk::ExtrudedContour*>(this)->m_ProjectedContourBounds, polygonNormal) == 1 )
     return true;
   else
     return false;
 
 }
 
 mitk::ScalarType mitk::ExtrudedContour::GetVolume()
 {
   return -1.0;
 }
 
 void mitk::ExtrudedContour::UpdateOutputInformation()
 {
   if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
   if(GetMTime() > m_LastCalculateExtrusionTime)
   {
     BuildGeometry();
     BuildSurface();
   }
   //if ( ( m_CalculateBoundingBox ) && ( m_PolyDataSeries.size() > 0 ) )
   //  CalculateBoundingBox();
 }
 
 void mitk::ExtrudedContour::BuildSurface()
 {
   if(m_Contour.IsNull())
   {
     SetVtkPolyData(NULL);
     return;
   }
 
   // set extrusion contour
   vtkPolyData *polyData = vtkPolyData::New();
   vtkCellArray *polys   = vtkCellArray::New();
 
   polys->InsertNextCell(m_Polygon->GetPointIds());
   polyData->SetPoints(m_Polygon->GetPoints());
 
   //float vtkpoint[3];
   //unsigned int i, numPts = m_Polygon->GetNumberOfPoints();
   //for(i=0; i<numPts; ++i)
   //{
   //  float * vtkpoint = this->m_Polygon->Points->GetPoint(i);
 
   //  pointids[i]=loopPoints->InsertNextPoint(vtkpoint);
   //}
   //polys->InsertNextCell( i, pointids );
   //delete [] pointids;
 
   //polyData->SetPoints( loopPoints );
   polyData->SetPolys( polys );
   polys->Delete();
 
   m_ExtrusionFilter->SetInput(polyData);
 
   polyData->Delete();
 
   // set extrusion scale factor
   m_ExtrusionFilter->SetScaleFactor(GetGeometry()->GetExtentInMM(2));
   SetVtkPolyData(m_SubdivisionFilter->GetOutput());
   //if(m_ClippingGeometry.IsNull())
   //{
   //  SetVtkPolyData(m_SubdivisionFilter->GetOutput());
   //}
   //else
   //{
   //  m_ClipPolyDataFilter->SetInput(m_SubdivisionFilter->GetOutput());
   //  mitk::BoundingBox::BoundsArrayType bounds=m_ClippingGeometry->GetBounds();
 
   //  m_ClippingBox->SetBounds(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]);
   //  m_ClippingBox->SetTransform(GetGeometry()->GetVtkTransform());
   //  m_ClipPolyDataFilter->SetClipFunction(m_ClippingBox);
   //  m_ClipPolyDataFilter->SetValue(0);
   //  SetVtkPolyData(m_ClipPolyDataFilter->GetOutput());
   //}
 
   m_LastCalculateExtrusionTime.Modified();
 }
 
 void mitk::ExtrudedContour::BuildGeometry()
 {
   if(m_Contour.IsNull())
     return;
 
 //  Initialize(1);
 
   Vector3D nullvector; nullvector.Fill(0.0);
   float xProj[3];
   unsigned int i;
   unsigned int numPts = 20; //m_Contour->GetNumberOfPoints();
   mitk::Contour::PathPointer path = m_Contour->GetContourPath();
   mitk::Contour::PathType::InputType cstart = path->StartOfInput();
   mitk::Contour::PathType::InputType cend   = path->EndOfInput();
   mitk::Contour::PathType::InputType cstep  = (cend-cstart)/numPts;
   mitk::Contour::PathType::InputType ccur;
 
   // Part I: guarantee/calculate legal vectors
 
   m_Vector.Normalize();
   itk2vtk(m_Vector, m_Normal);
   // check m_Vector
   if(mitk::Equal(m_Vector, nullvector) || m_AutomaticVectorGeneration)
   {
     if ( m_AutomaticVectorGeneration == false)
       itkWarningMacro("Extrusion vector is 0 ("<< m_Vector << "); trying to use normal of polygon");
 
     vtkPoints *loopPoints = vtkPoints::New();
     //mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
     double vtkpoint[3];
 
     unsigned int i=0;
     for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
     {
       itk2vtk(path->Evaluate(ccur), vtkpoint);
       loopPoints->InsertNextPoint(vtkpoint);
     }
 
     // Make sure points define a loop with a m_Normal
     vtkPolygon::ComputeNormal(loopPoints, m_Normal);
     loopPoints->Delete();
 
     vtk2itk(m_Normal, m_Vector);
     if(mitk::Equal(m_Vector, nullvector))
     {
       itkExceptionMacro("Cannot calculate normal of polygon");
     }
   }
   // check m_RightVector
   if((mitk::Equal(m_RightVector, nullvector)) || (mitk::Equal(m_RightVector*m_Vector, 0.0)==false))
   {
     if(mitk::Equal(m_RightVector, nullvector))
     {
       itkDebugMacro("Right vector is 0. Calculating.");
     }
     else
     {
       itkWarningMacro("Right vector ("<<m_RightVector<<") not perpendicular to extrusion vector "<<m_Vector<<": "<<m_RightVector*m_Vector);
     }
     // calculate a legal m_RightVector
     if( mitk::Equal( m_Vector[1], 0.0f ) == false )
     {
       FillVector3D( m_RightVector, 1.0f, -m_Vector[0]/m_Vector[1], 0.0f );
       m_RightVector.Normalize();
     }
     else
     {
       FillVector3D( m_RightVector, 0.0f, 1.0f, 0.0f );
     }
   }
 
   // calculate down-vector
   VnlVector rightDV = m_RightVector.GetVnlVector(); rightDV.normalize(); vnl2vtk(rightDV, m_Right);
   VnlVector downDV  = vnl_cross_3d( m_Vector.GetVnlVector(), rightDV ); downDV.normalize();  vnl2vtk(downDV,  m_Down);
 
   // Part II: calculate plane as base for extrusion, project the contour
   // on this plane and store as polygon for IsInside test and BoundingBox calculation
 
   // initialize m_ProjectionPlane, yet with origin at 0
   m_ProjectionPlane->InitializeStandardPlane(rightDV, downDV);
 
   // create vtkPolygon from contour and simultaneously determine 2D bounds of
   // contour projected on m_ProjectionPlane
   //mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
   m_Polygon->Points->Reset();
   m_Polygon->Points->SetNumberOfPoints(numPts);
   m_Polygon->PointIds->Reset();
   m_Polygon->PointIds->SetNumberOfIds(numPts);
   mitk::Point2D pt2d;
   mitk::Point3D pt3d;
   mitk::Point2D min, max;
   min.Fill(ScalarTypeNumericTraits::max());
   max.Fill(ScalarTypeNumericTraits::min());
   xProj[2]=0.0;
   for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
   {
     pt3d.CastFrom(path->Evaluate(ccur));
     m_ProjectionPlane->Map(pt3d, pt2d);
     xProj[0]=pt2d[0];
     if(pt2d[0]<min[0]) min[0]=pt2d[0];
     if(pt2d[0]>max[0]) max[0]=pt2d[0];
     xProj[1]=pt2d[1];
     if(pt2d[1]<min[1]) min[1]=pt2d[1];
     if(pt2d[1]>max[1]) max[1]=pt2d[1];
     m_Polygon->Points->SetPoint(i, xProj);
     m_Polygon->PointIds->SetId(i, i);
   }
   // shift parametric origin to (0,0)
   for(i=0; i<numPts; ++i)
   {
     double * pt = this->m_Polygon->Points->GetPoint(i);
 
     pt[0]-=min[0]; pt[1]-=min[1];
     itkDebugMacro( << i << ": (" << pt[0] << "," << pt[1] << "," << pt[2] << ")" );
   }
   this->m_Polygon->GetBounds(m_ProjectedContourBounds);
   //m_ProjectedContourBounds[4]=-1.0; m_ProjectedContourBounds[5]=1.0;
 
   // calculate origin (except translation along the normal) and bounds
   // of m_ProjectionPlane:
   //  origin is composed of the minimum x-/y-coordinates of the polygon,
   //  bounds from the extent of the polygon, both after projecting on the plane
   mitk::Point3D origin;
   m_ProjectionPlane->Map(min, origin);
   ScalarType bounds[6]={0, max[0]-min[0], 0, max[1]-min[1], 0, 1};
   m_ProjectionPlane->SetBounds(bounds);
   m_ProjectionPlane->SetOrigin(origin);
 
   // Part III: initialize geometry
   if(m_ClippingGeometry.IsNotNull())
   {
     ScalarType min_dist=ScalarTypeNumericTraits::max(), max_dist=ScalarTypeNumericTraits::min(), dist;
     unsigned char i;
     for(i=0; i<8; ++i)
     {
       dist = m_ProjectionPlane->SignedDistance( m_ClippingGeometry->GetCornerPoint(i) );
       if(dist<min_dist) min_dist=dist;
       if(dist>max_dist) max_dist=dist;
     }
     //incorporate translation along the normal into origin
     origin = origin+m_Vector*min_dist;
     m_ProjectionPlane->SetOrigin(origin);
     bounds[5]=max_dist-min_dist;
   }
   else
     bounds[5]=20;
 
   itk2vtk(origin, m_Origin);
 
-  mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
-  mitk::Geometry3D::Pointer g3d = timeGeometry->GetGeometry3D( 0 );
+  mitk::Geometry3D::Pointer g3d = GetGeometry( 0 );
   assert( g3d.IsNotNull() );
   g3d->SetBounds(bounds);
   g3d->SetIndexToWorldTransform(m_ProjectionPlane->GetIndexToWorldTransform());
   g3d->TransferItkToVtkTransform();
-  timeGeometry->InitializeEvenlyTimed(g3d, 1);
+
+  ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+  timeGeometry->Initialize(g3d,1);
+  SetTimeGeometry(timeGeometry);
+
 }
 
 unsigned long mitk::ExtrudedContour::GetMTime() const
 {
   unsigned long latestTime = Superclass::GetMTime();
   if(m_Contour.IsNotNull())
   {
     unsigned long localTime;
     localTime = m_Contour->GetMTime();
     if(localTime > latestTime) latestTime = localTime;
   }
   return latestTime;
 }
diff --git a/Modules/Segmentation/IO/mitkContourModelWriter.cpp b/Modules/Segmentation/IO/mitkContourModelWriter.cpp
index d323e4771a..a6f7f30566 100644
--- a/Modules/Segmentation/IO/mitkContourModelWriter.cpp
+++ b/Modules/Segmentation/IO/mitkContourModelWriter.cpp
@@ -1,488 +1,488 @@
 /*===================================================================
 
 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 "mitkContourModelWriter.h"
 #include <iostream>
 #include <fstream>
 #include <locale>
 
 
 /*
  * The xml file will look like:
  *
  *   <?xml version="1.0" encoding="utf-8"?>
  *   <contourModel>
  *      <head>
  *        <geometryInfo>
  *        </geometryInfo>
  *      </head>
  *      <data>
  *        <timestep n="0">
  *          <controlPoints>
  *            <point>
  *              <x></x>
  *              <y></y>
  *              <z></z>
  *            </point>
  *          </controlPoint>
  *        </timestep>
  *      </data>
  *    </contourModel>
  */
 
 
 //
 // Initialization of the xml tags.
 //
 
 const char* mitk::ContourModelWriter::XML_CONTOURMODEL = "contourModel" ;
 
 const char* mitk::ContourModelWriter::XML_HEAD = "head" ;
 
 const char* mitk::ContourModelWriter::XML_GEOMETRY_INFO = "geometryInfo" ;
 
 const char* mitk::ContourModelWriter::XML_DATA = "data";
 
 const char* mitk::ContourModelWriter::XML_TIME_STEP = "timestep";
 
 const char* mitk::ContourModelWriter::XML_CONTROL_POINTS = "controlPoints" ;
 
 const char* mitk::ContourModelWriter::XML_POINT = "point" ;
 
 const char* mitk::ContourModelWriter::XML_X = "x" ;
 
 const char* mitk::ContourModelWriter::XML_Y = "y" ;
 
 const char* mitk::ContourModelWriter::XML_Z = "z" ;
 
 
 
 
 mitk::ContourModelWriter::ContourModelWriter()
     : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
     this->SetNumberOfRequiredInputs( 1 );
     this->SetNumberOfOutputs( 1 );
     this->SetNthOutput( 0, mitk::ContourModel::New().GetPointer() );
     m_Indent = 2;
     m_IndentDepth = 0;
     m_Success = false;
 }
 
 
 
 
 mitk::ContourModelWriter::~ContourModelWriter()
 {}
 
 
 
 
 void mitk::ContourModelWriter::GenerateData()
 {
     m_Success = false;
     m_IndentDepth = 0;
 
     //
     // Opening the file to write to
     //
     if ( m_FileName == "" )
     {
         itkWarningMacro( << "Sorry, filename has not been set!" );
         return ;
     }
     std::ofstream out( m_FileName.c_str() );
     if ( !out.good() )
     {
       itkExceptionMacro(<< "File " << m_FileName << " could not be opened!");
       itkWarningMacro( << "Sorry, file " << m_FileName << " could not be opened!" );
       out.close();
         return ;
     }
 
     std::locale previousLocale(out.getloc());
     std::locale I("C");
     out.imbue(I);
 
 
 /*+++++++++++ Here the actual xml writing begins +++++++++*/
 
     /*++++ <?xml version="1.0" encoding="utf-8"?> ++++*/
     WriteXMLHeader( out );
     /*++++ <contourModel> ++++*/
     WriteStartElement( XML_CONTOURMODEL, out );
 
     /*++++ <head> ++++*/
     WriteStartElement( XML_HEAD, out);
 
     /*++++ <geometryInfo> ++++*/
     WriteStartElement( XML_GEOMETRY_INFO, out);
 
 
     //write the geometry informations to the stream
       InputType::Pointer contourModel = this->GetInput();
       assert( contourModel.IsNotNull() );
-      WriteGeometryInformation( contourModel->GetTimeSlicedGeometry(), out);;
+      WriteGeometryInformation( contourModel->GetTimeGeometry(), out);;
 
 
     /*++++ </geometryInfo> ++++*/
     WriteEndElement( XML_GEOMETRY_INFO, out);
 
     /*++++ </head> ++++*/
     WriteEndElement( XML_HEAD, out);
 
     //
     // for each input object write its xml representation to
     // the stream
     //
     for ( unsigned int i = 0 ; i < this->GetNumberOfInputs(); ++i )
     {
         InputType::Pointer contourModel = this->GetInput( i );
         assert( contourModel.IsNotNull() );
         WriteXML( contourModel.GetPointer(), out );
     }
 
 
     /*++++ </contourModel> ++++*/
     WriteEndElement( XML_CONTOURMODEL, out );
 
 
     out.imbue(previousLocale);
 
     if ( !out.good() ) // some error during output
     {
       out.close();
       throw std::ios_base::failure("Some error during point set writing.");
     }
 
     out.close();
     m_Success = true;
     m_MimeType = "application/MITK.ContourModel";
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteXML( mitk::ContourModel* contourModel, std::ofstream& out )
 {
   /*++++ <data> ++++*/
   WriteStartElement( XML_DATA, out);
 
   unsigned int timecount = contourModel->GetTimeSteps();
 
   for(unsigned int i=0; i< timecount; i++)
   {
     /*++++ <timestep> ++++*/
     std::vector<std::string> at;
     at.push_back("n");
     std::vector<std::string> val;
     val.push_back(ConvertToString(i));
 
     at.push_back("isClosed");
     val.push_back(ConvertToString(contourModel->IsClosed()));
 
     WriteStartElementWithAttribut( XML_TIME_STEP, at, val, out );
 
     /*++++ <controlPoints> ++++*/
     WriteStartElement(XML_CONTROL_POINTS, out);
 
     mitk::ContourModel::VertexIterator it = contourModel->IteratorBegin();
     mitk::ContourModel::VertexIterator end = contourModel->IteratorEnd();
 
 
     while(it != end)
     {
       mitk::ContourModel::VertexType* v = *it;
 
       /*++++ <point> ++++*/
       std::vector<std::string> attr;
       attr.push_back("IsControlPoint");
       std::vector<std::string> value;
       value.push_back(ConvertToString(v->IsControlPoint));
       WriteStartElementWithAttribut( XML_POINT, attr, value, out );
 
 
       /*++++ <x> ++++*/
       WriteStartElement( XML_X, out );
       WriteCharacterData( ConvertToString(v->Coordinates[0] ).c_str(), out );
       /*++++ </x> ++++*/
       WriteEndElement( XML_X, out, false );
 
       /*++++ <y> ++++*/
       WriteStartElement( XML_Y, out );
       WriteCharacterData( ConvertToString( v->Coordinates[1] ).c_str(), out );
       /*++++ </y> ++++*/
       WriteEndElement( XML_Y, out, false );
 
       /*++++ <z> ++++*/
       WriteStartElement( XML_Z, out );
       WriteCharacterData( ConvertToString( v->Coordinates[2] ).c_str(), out );
       /*++++ </z> ++++*/
       WriteEndElement( XML_Z, out, false );
 
       /*++++ </point> ++++*/
       WriteEndElement( XML_POINT, out );
 
       it++;
     }
 
     /*++++ </controlPoints> ++++*/
     WriteEndElement(XML_CONTROL_POINTS, out);
 
     /*++++ </timestep> ++++*/
     WriteEndElement( XML_TIME_STEP, out );
 
   }
 
   /*++++ </data> ++++*/
   WriteEndElement( XML_DATA, out );
 }
 
 
 
-void mitk::ContourModelWriter::WriteGeometryInformation( mitk::TimeSlicedGeometry* geometry, std::ofstream& out )
+void mitk::ContourModelWriter::WriteGeometryInformation( mitk::TimeGeometry* geometry, std::ofstream& out )
 {
   WriteCharacterData("<!-- geometry information -->", out);
 }
 
 
 
 void mitk::ContourModelWriter::ResizeInputs( const unsigned int& num )
 {
     unsigned int prevNum = this->GetNumberOfInputs();
     this->SetNumberOfInputs( num );
     for ( unsigned int i = prevNum; i < num; ++i )
     {
         this->SetNthInput( i, mitk::ContourModel::New().GetPointer() );
     }
 }
 
 
 
 
 void mitk::ContourModelWriter::SetInput( InputType* contourModel )
 {
     this->ProcessObject::SetNthInput( 0, contourModel );
 }
 
 
 
 
 void mitk::ContourModelWriter::SetInput( const unsigned int& id, InputType* contourModel )
 {
     if ( id >= this->GetNumberOfInputs() )
         this->ResizeInputs( id + 1 );
     this->ProcessObject::SetNthInput( id, contourModel );
 }
 
 
 
 mitk::ContourModel* mitk::ContourModelWriter::GetInput()
 {
     if ( this->GetNumberOfInputs() < 1 )
     {
         return 0;
     }
     else
     {
         return dynamic_cast<InputType*> ( this->GetInput( 0 ) );
     }
 }
 
 
 
 
 mitk::ContourModel* mitk::ContourModelWriter::GetInput( const unsigned int& num )
 {
     return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( num ) );
 }
 
 
 
 
 
 template < typename T>
 std::string mitk::ContourModelWriter::ConvertToString( T value )
 {
     std::ostringstream o;
     std::locale I("C");
     o.imbue(I);
 
     if ( o << value )
     {
         return o.str();
      }
     else
         return "conversion error";
 }
 
 
 
 void mitk::ContourModelWriter::WriteXMLHeader( std::ofstream &file )
 {
     file << "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteStartElement( const char *const tag, std::ofstream &file )
 {
     file << std::endl;
     WriteIndent( file );
     file << '<' << tag << '>';
     m_IndentDepth++;
 }
 
 
 
 void mitk::ContourModelWriter::WriteStartElementWithAttribut( const char *const tag, std::vector<std::string> attributes, std::vector<std::string> values, std::ofstream &file )
 {
     file << std::endl;
     WriteIndent( file );
     file << '<' << tag;
 
     unsigned int attributesSize = attributes.size();
     unsigned int valuesSize = values.size();
 
     if( attributesSize == valuesSize){
       std::vector<std::string>::iterator attributesIt = attributes.begin();
       std::vector<std::string>::iterator end = attributes.end();
 
       std::vector<std::string>::iterator valuesIt = values.begin();
 
       while(attributesIt != end)
       {
         file << ' ';
         WriteCharacterData( *attributesIt, file);
         file << '=' << '"';
         WriteCharacterData( *valuesIt, file);
         file << '"';
         attributesIt++;
         valuesIt++;
       }
     }
 
 
     file << '>';
     m_IndentDepth++;
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteEndElement( const char *const tag, std::ofstream &file, const bool& indent )
 {
     m_IndentDepth--;
     if ( indent )
     {
         file << std::endl;
         WriteIndent( file );
     }
     file << '<' << '/' << tag << '>';
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteCharacterData( const char *const data, std::ofstream &file )
 {
     file << data;
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteStartElement( std::string &tag, std::ofstream &file )
 {
     WriteStartElement( tag.c_str(), file );
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteEndElement( std::string &tag, std::ofstream &file, const bool& indent )
 {
     WriteEndElement( tag.c_str(), file, indent );
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteCharacterData( std::string &data, std::ofstream &file )
 {
     WriteCharacterData( data.c_str(), file );
 }
 
 
 
 
 void mitk::ContourModelWriter::WriteIndent( std::ofstream& file )
 {
     std::string spaces( m_IndentDepth * m_Indent, ' ' );
     file << spaces.c_str();
 }
 
 
 
 bool mitk::ContourModelWriter::GetSuccess() const
 {
     return m_Success;
 }
 
 
 
 bool mitk::ContourModelWriter::CanWriteDataType( DataNode* input )
 {
   if ( input )
   {
     mitk::BaseData* data = input->GetData();
     if ( data )
     {
        mitk::ContourModel::Pointer contourModel = dynamic_cast<mitk::ContourModel*>( data );
        if( contourModel.IsNotNull() )
        {
          //this writer has no "SetDefaultExtension()" - function
          m_Extension = ".cnt";
          return true;
        }
     }
   }
   return false;
 }
 
 void mitk::ContourModelWriter::SetInput( DataNode* input )
 {
   if( input && CanWriteDataType( input ) )
     this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::ContourModel*>( input->GetData() ) );
 }
 
 std::string mitk::ContourModelWriter::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 std::vector<std::string> mitk::ContourModelWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".cnt");
   return possibleFileExtensions;
 }
 
 std::string mitk::ContourModelWriter::GetFileExtension()
 {
   return m_Extension;
 }
diff --git a/Modules/Segmentation/IO/mitkContourModelWriter.h b/Modules/Segmentation/IO/mitkContourModelWriter.h
index ea02a0d21e..d9d745dff5 100644
--- a/Modules/Segmentation/IO/mitkContourModelWriter.h
+++ b/Modules/Segmentation/IO/mitkContourModelWriter.h
@@ -1,285 +1,298 @@
 /*===================================================================
 
 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_WRITER__H_
 #define _MITK_CONTOURMODEL_WRITER__H_
 
 #include "SegmentationExports.h"
 #include <itkProcessObject.h>
 #include <mitkFileWriterWithInformation.h>
 #include <mitkContourModel.h>
 
+//DEPRECATED
+#include <mitkTimeSlicedGeometry.h>
+
 namespace mitk
 {
 
 /**
  * @brief XML-based writer for mitk::ContourModels
  *
  * XML-based writer for mitk::ContourModels. Multiple ContourModels can be written in
  * a single XML file by simply setting multiple inputs to the filter.
  *
  * @ingroup PSIO
  * @ingroup Process
  */
 class Segmentation_EXPORT ContourModelWriter : public mitk::FileWriterWithInformation
 {
 public:
 
     mitkClassMacro( ContourModelWriter, mitk::FileWriter );
 
     mitkWriterMacro;
 
     itkNewMacro( Self );
 
     typedef mitk::ContourModel InputType;
 
     typedef InputType::Pointer InputTypePointer;
 
     /**
      * Sets the filename of the file to write.
      * @param FileName the name of the file to write.
      */
     itkSetStringMacro( FileName );
 
     /**
      * @returns the name of the file to be written to disk.
      */
     itkGetStringMacro( FileName );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkSetStringMacro( FilePrefix );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkGetStringMacro( FilePrefix );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkSetStringMacro( FilePattern );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkGetStringMacro( FilePattern );
 
     /**
      * Sets the 0'th input object for the filter.
      * @param input the first input for the filter.
      */
     void SetInput( InputType* input );
 
     /**
      * Sets the n'th input object for the filter. If num is
      * larger than GetNumberOfInputs() the number of inputs is
      * resized appropriately.
      * @param input the n'th input for the filter.
      */
     void SetInput( const unsigned int& num, InputType* input);
 
     /**
      * @returns the 0'th input object of the filter.
      */
     ContourModel* GetInput();
 
     /**
      * @param num the index of the desired output object.
      * @returns the n'th input object of the filter.
      */
     ContourModel* GetInput( const unsigned int& num );
 
 
     /**
     * @brief Return the possible file extensions for the data type associated with the writer
     */
     virtual std::vector<std::string> GetPossibleFileExtensions();
 
     /**
     * @brief Return the extension to be added to the filename.
     */
     virtual std::string GetFileExtension();
 
     /**
     * @brief Check if the Writer can write the Content of the
     */
     virtual bool CanWriteDataType( DataNode* );
 
     /**
     * @brief Return the MimeType of the saved File.
     */
     virtual std::string GetWritenMIMEType();
 
     /**
     * @brief Set the DataTreenode as Input. Important: The Writer always have a SetInput-Function.
     */
     virtual void SetInput( DataNode* );
 
     /**
     * @returns whether the last write attempt was successful or not.
     */
     bool GetSuccess() const;
 
     /*++++++ FileWriterWithInformation methods +++++++*/
     virtual const char *GetDefaultFilename() { return "ContourModel.cnt"; }
     virtual const char *GetFileDialogPattern() { return "MITK ContourModel (*.cnt)"; }
     virtual const char *GetDefaultExtension() { return ".cnt"; }
     virtual bool CanWriteBaseDataType(BaseData::Pointer data) { return (dynamic_cast<mitk::ContourModel *>(data.GetPointer()) != NULL); };
     virtual void DoWrite(BaseData::Pointer data)
     {
       if (this->CanWriteBaseDataType(data))
       {
         this->SetInput(dynamic_cast<mitk::ContourModel *>(data.GetPointer()));
         this->Update();
       }
     }
 
 protected:
 
     /**
      * Constructor.
      */
     ContourModelWriter();
 
     /**
      * Virtual destructor.
      */
     virtual ~ContourModelWriter();
 
 
     /**
      * Writes the XML file
      */
     virtual void GenerateData();
 
 
     /**
      * Resizes the number of inputs of the writer.
      * The inputs are initialized by empty ContourModels
      * @param num the new number of inputs
      */
     virtual void ResizeInputs( const unsigned int& num );
 
 
     /**
      * Converts an arbitrary type to a string. The type has to
      * support the << operator. This works fine at least for integral
      * data types as float, int, long etc.
      * @param value the value to convert
      * @returns the string representation of value
      */
     template < typename T>
     std::string ConvertToString( T value );
 
     /**
      * Writes an XML representation of the given point set to
      * an outstream. The XML-Header an root node is not included!
      * @param contourModel the point set to be converted to xml
      * @param out the stream to write to.
      */
     void WriteXML( mitk::ContourModel* contourModel, std::ofstream& out );
 
     /**
-    * Writes the geometry information of the TimeSlicedGeometry to an outstream.
+    * Writes the geometry information of the TimeGeometry to an outstream.
+    * The root tag is not included.
+    * @param geometry the TimeGeometry of the contour.
+    * @param the stream to write to.
+    */
+    void WriteGeometryInformation( mitk::TimeGeometry* geometry, std::ofstream& out );
+
+    /**
+    * Writes the geometry information of the TimeGeometry to an outstream.
     * The root tag is not included.
-    * @param geometry the TimeSlicedGeometry of the contour.
+    * @param geometry the TimeGeometry of the contour.
     * @param the stream to write to.
+    *
+    * \deprecatedSince{2013_06} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see @TimeGeometryGuide@
     */
-    void WriteGeometryInformation( mitk::TimeSlicedGeometry* geometry, std::ofstream& out );
+    DEPRECATED(void WriteGeometryInformation( mitk::TimeSlicedGeometry* geometry, std::ofstream& out ));
 
     /**
      * Writes an standard xml header to the given stream.
      * @param file the stream in which the header is written.
      */
     void WriteXMLHeader( std::ofstream &file );
 
     /** Write a start element tag */
     void WriteStartElement( const char *const tag, std::ofstream &file );
 
     void WriteStartElementWithAttribut( const char *const tag, std::vector<std::string> attributes, std::vector<std::string> values, std::ofstream &file );
 
     /**
      * Write an end element tag
      * End-Elements following character data should pass indent = false.
      */
     void WriteEndElement( const char *const tag, std::ofstream &file, const bool& indent = true );
 
     /** Write character data inside a tag. */
     void WriteCharacterData( const char *const data, std::ofstream &file );
 
     /** Write a start element tag */
     void WriteStartElement( std::string &tag, std::ofstream &file );
 
     /** Write an end element tag */
     void WriteEndElement( std::string &tag, std::ofstream &file, const bool& indent = true );
 
     /** Write character data inside a tag. */
     void WriteCharacterData( std::string &data, std::ofstream &file );
 
     /** Writes empty spaces to the stream according to m_IndentDepth and m_Indent */
     void WriteIndent( std::ofstream& file );
 
     std::string m_FileName;
 
     std::string m_FilePrefix;
 
     std::string m_FilePattern;
 
     std::string m_Extension;
 
     std::string m_MimeType;
 
     unsigned int m_IndentDepth;
 
     unsigned int m_Indent;
 
     bool m_Success;
 
 
 
 public:
 
     static const char* XML_CONTOURMODEL;
 
     static const char* XML_HEAD;
 
     static const char* XML_GEOMETRY_INFO;
 
     static const char* XML_DATA;
 
     static const char* XML_TIME_STEP;
 
     static const char* XML_CONTROL_POINTS;
 
     static const char* XML_POINT;
 
     static const char* XML_X;
 
     static const char* XML_Y;
 
     static const char* XML_Z;
 
 
 };
 
 
 
 }
 
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
index fd808965b9..8da544e93a 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
@@ -1,469 +1,469 @@
 /*===================================================================
 
 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 "mitkFastMarchingTool.h"
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkInteractionConst.h"
 
 #include "itkOrImageFilter.h"
 #include "mitkImageTimeSelector.h"
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, FastMarchingTool, "FastMarching2D tool");
 }
 
 
 mitk::FastMarchingTool::FastMarchingTool()
 :FeedbackContourTool("PressMoveReleaseAndPointSetting"),
 m_NeedUpdate(true),
 m_CurrentTimeStep(0),
 m_LowerThreshold(0),
 m_UpperThreshold(200),
 m_StoppingValue(100),
 m_Sigma(1.0),
 m_Alpha(-0.5),
 m_Beta(3.0),
 m_PositionEvent(0)
 {
   CONNECT_ACTION( AcADDPOINTRMB, OnAddPoint );
   CONNECT_ACTION( AcADDPOINT, OnAddPoint );
   CONNECT_ACTION( AcREMOVEPOINT, OnDelete );
 }
 
 mitk::FastMarchingTool::~FastMarchingTool()
 {
   if (this->m_SmoothFilter.IsNotNull())
       this->m_SmoothFilter->RemoveAllObservers();
 
   if (this->m_SigmoidFilter.IsNotNull())
       this->m_SigmoidFilter->RemoveAllObservers();
 
   if (this->m_GradientMagnitudeFilter.IsNotNull())
       this->m_GradientMagnitudeFilter->RemoveAllObservers();
 
   if (this->m_FastMarchingFilter.IsNotNull())
       this->m_FastMarchingFilter->RemoveAllObservers();
 }
 
 
 float mitk::FastMarchingTool::CanHandleEvent( StateEvent const *stateEvent) const
 {
   float returnValue = Superclass::CanHandleEvent(stateEvent);
 
   //we can handle delete
   if(stateEvent->GetId() == 12 )
   {
     returnValue = 1.0;
   }
 
   return returnValue;
 }
 
 
 const char** mitk::FastMarchingTool::GetXPM() const
 {
   return NULL;//mitkFastMarchingTool_xpm;
 }
 
 us::ModuleResource mitk::FastMarchingTool::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::FastMarchingTool::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_Cursor_32x32.png");
   return resource;
 }
 
 const char* mitk::FastMarchingTool::GetName() const
 {
   return "FastMarching2D";
 }
 
 void mitk::FastMarchingTool::BuildITKPipeline()
 {
   m_ReferenceImageSliceAsITK = InternalImageType::New();
 
   m_ReferenceImageSlice = GetAffectedReferenceSlice( m_PositionEvent );
   CastToItkImage(m_ReferenceImageSlice, m_ReferenceImageSliceAsITK);
 
   m_ProgressCommand = mitk::ToolCommand::New();
 
   m_SmoothFilter = SmoothingFilterType::New();
   m_SmoothFilter->SetInput( m_ReferenceImageSliceAsITK );
   m_SmoothFilter->SetTimeStep( 0.05 );
   m_SmoothFilter->SetNumberOfIterations( 2 );
   m_SmoothFilter->SetConductanceParameter( 9.0 );
 
   m_GradientMagnitudeFilter = GradientFilterType::New();
   m_GradientMagnitudeFilter->SetSigma( m_Sigma );
 
   m_SigmoidFilter = SigmoidFilterType::New();
   m_SigmoidFilter->SetAlpha( m_Alpha );
   m_SigmoidFilter->SetBeta( m_Beta );
   m_SigmoidFilter->SetOutputMinimum( 0.0 );
   m_SigmoidFilter->SetOutputMaximum( 1.0 );
 
   m_FastMarchingFilter = FastMarchingFilterType::New();
   m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
 
   m_ThresholdFilter = ThresholdingFilterType::New();
   m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
   m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
   m_ThresholdFilter->SetOutsideValue( 0 );
   m_ThresholdFilter->SetInsideValue( 1.0 );
 
   m_SeedContainer = NodeContainer::New();
   m_SeedContainer->Initialize();
   m_FastMarchingFilter->SetTrialPoints( m_SeedContainer );
 
   if (this->m_SmoothFilter.IsNotNull())
       this->m_SmoothFilter->RemoveAllObservers();
 
   if (this->m_SigmoidFilter.IsNotNull())
       this->m_SigmoidFilter->RemoveAllObservers();
 
   if (this->m_GradientMagnitudeFilter.IsNotNull())
       this->m_GradientMagnitudeFilter->RemoveAllObservers();
 
   if (this->m_FastMarchingFilter.IsNotNull())
       this->m_FastMarchingFilter->RemoveAllObservers();
 
   m_SmoothFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_GradientMagnitudeFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_SigmoidFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_FastMarchingFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
 
   m_SmoothFilter->SetInput( m_ReferenceImageSliceAsITK );
   m_GradientMagnitudeFilter->SetInput( m_SmoothFilter->GetOutput() );
   m_SigmoidFilter->SetInput( m_GradientMagnitudeFilter->GetOutput() );
   m_FastMarchingFilter->SetInput( m_SigmoidFilter->GetOutput() );
   m_ThresholdFilter->SetInput( m_FastMarchingFilter->GetOutput() );
   m_ReferenceImageSliceAsITK = InternalImageType::New();
 }
 
 void mitk::FastMarchingTool::SetUpperThreshold(double value)
 {
  if (m_UpperThreshold != value)
  {
     m_UpperThreshold = value / 10.0;
     m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
     m_NeedUpdate = true;
  }
 }
 
 void mitk::FastMarchingTool::SetLowerThreshold(double value)
 {
   if (m_LowerThreshold != value)
   {
     m_LowerThreshold = value / 10.0;
     m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
     m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetBeta(double value)
 {
   if (m_Beta != value)
   {
     m_Beta = value;
     m_SigmoidFilter->SetBeta( m_Beta );
     m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetSigma(double value)
 {
   if (m_Sigma != value)
   {
     m_Sigma = value;
     m_GradientMagnitudeFilter->SetSigma( m_Sigma );
     m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetAlpha(double value)
 {
   if (m_Alpha != value)
   {
       m_Alpha = value;
       m_SigmoidFilter->SetAlpha( m_Alpha );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetStoppingValue(double value)
 {
   if (m_StoppingValue != value)
   {
       m_StoppingValue = value;
       m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::Activated()
 {
   Superclass::Activated();
 
   m_ResultImageNode = mitk::DataNode::New();
   m_ResultImageNode->SetName("FastMarching_Preview");
   m_ResultImageNode->SetBoolProperty("helper object", true);
   m_ResultImageNode->SetColor(0.0, 1.0, 0.0);
   m_ResultImageNode->SetVisibility(true);
   m_ToolManager->GetDataStorage()->Add( this->m_ResultImageNode, m_ToolManager->GetReferenceData(0));
 
   m_SeedsAsPointSet = mitk::PointSet::New();
   m_SeedsAsPointSetNode = mitk::DataNode::New();
   m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
   m_SeedsAsPointSetNode->SetName("Seeds_Preview");
   m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
   m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
   m_SeedsAsPointSetNode->SetVisibility(true);
   m_ToolManager->GetDataStorage()->Add( this->m_SeedsAsPointSetNode, m_ToolManager->GetReferenceData(0));
 
   this->Initialize();
 }
 
 void mitk::FastMarchingTool::Deactivated()
 {
   Superclass::Deactivated();
   m_ToolManager->GetDataStorage()->Remove( this->m_ResultImageNode );
   m_ToolManager->GetDataStorage()->Remove( this->m_SeedsAsPointSetNode );
   this->ClearSeeds();
   m_ResultImageNode = NULL;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::FastMarchingTool::Initialize()
 {
   m_ReferenceImage = dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData());
-  if(m_ReferenceImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
+  if(m_ReferenceImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
     timeSelector->SetInput( m_ReferenceImage );
     timeSelector->SetTimeNr( m_CurrentTimeStep );
     timeSelector->UpdateLargestPossibleRegion();
     m_ReferenceImage = timeSelector->GetOutput();
   }
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool::ConfirmSegmentation()
 {
   // combine preview image with current working segmentation
   if (dynamic_cast<mitk::Image*>(m_ResultImageNode->GetData()))
   {
     //logical or combination of preview and segmentation slice
     OutputImageType::Pointer workingImageSliceInITK = OutputImageType::New();
 
     mitk::Image::Pointer workingImageSlice;
     mitk::Image::Pointer workingImage = dynamic_cast<mitk::Image*>(this->m_ToolManager->GetWorkingData(0)->GetData());
-    if(workingImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
+    if(workingImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput( workingImage );
       timeSelector->SetTimeNr( m_CurrentTimeStep );
       timeSelector->UpdateLargestPossibleRegion();
       // todo: make GetAffectedWorkingSlice dependant of current time step
       workingImageSlice = GetAffectedWorkingSlice( m_PositionEvent );
       CastToItkImage( workingImageSlice, workingImageSliceInITK );
     }
     else
     {
       workingImageSlice = GetAffectedWorkingSlice( m_PositionEvent );
       CastToItkImage( workingImageSlice, workingImageSliceInITK );
     }
 
     typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
     OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
 
     orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
     orFilter->SetInput(1, workingImageSliceInITK);
     orFilter->Update();
 
     mitk::Image::Pointer segmentationResult = mitk::Image::New();
 
     mitk::CastToMitkImage(orFilter->GetOutput(), segmentationResult);
     segmentationResult->GetGeometry()->SetOrigin(workingImageSlice->GetGeometry()->GetOrigin());
     segmentationResult->GetGeometry()->SetIndexToWorldTransform(workingImageSlice->GetGeometry()->GetIndexToWorldTransform());
 
     //write to segmentation volume and hide preview image
     // again, current time step is not considered
     this->WriteBackSegmentationResult(m_PositionEvent, segmentationResult );
     this->m_ResultImageNode->SetVisibility(false);
 
     this->ClearSeeds();
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 bool mitk::FastMarchingTool::OnAddPoint(Action* action, const StateEvent* stateEvent)
 {
   // Add a new seed point for FastMarching algorithm
   const PositionEvent* p = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!p) return false;
 
   if (m_PositionEvent != NULL)
       delete m_PositionEvent;
   m_PositionEvent = new PositionEvent(p->GetSender(), p->GetType(), p->GetButton(), p->GetButtonState(), p->GetKey(), p->GetDisplayPosition(), p->GetWorldPosition() );
 
   //if click was on another renderwindow or slice then reset pipeline and preview
   if( (m_LastEventSender != m_PositionEvent->GetSender()) || (m_LastEventSlice != m_PositionEvent->GetSender()->GetSlice()) )
   {
       this->BuildITKPipeline();
       this->ClearSeeds();
   }
 
   m_LastEventSender = m_PositionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   mitk::Point3D clickInIndex;
 
   m_ReferenceImageSlice->GetGeometry()->WorldToIndex(m_PositionEvent->GetWorldPosition(), clickInIndex);
   itk::Index<2> seedPosition;
   seedPosition[0] = clickInIndex[0];
   seedPosition[1] = clickInIndex[1];
 
   NodeType node;
   const double seedValue = 0.0;
   node.SetValue( seedValue );
   node.SetIndex( seedPosition );
   this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
   m_FastMarchingFilter->Modified();
 
   m_SeedsAsPointSet->InsertPoint(m_SeedsAsPointSet->GetSize(), m_PositionEvent->GetWorldPosition());
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   m_NeedUpdate = true;
 
   this->Update();
 
   return true;
 }
 
 
 bool mitk::FastMarchingTool::OnDelete(Action* action, const StateEvent* stateEvent)
 {
   // delete last seed point
   if(!(this->m_SeedContainer->empty()))
   {
     //delete last element of seeds container
     this->m_SeedContainer->pop_back();
     m_FastMarchingFilter->Modified();
 
     //delete last point in pointset - somehow ugly
     m_SeedsAsPointSet->GetPointSet()->GetPoints()->DeleteIndex(m_SeedsAsPointSet->GetSize() - 1);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     m_NeedUpdate = true;
 
     this->Update();
   }
   return true;
 }
 
 
 void mitk::FastMarchingTool::Update()
 {
   // update FastMarching pipeline and show result
   if (m_NeedUpdate)
   {
     m_ProgressCommand->AddStepsToDo(20);
     CurrentlyBusy.Send(true);
     try
     {
       m_ThresholdFilter->Update();
     }
     catch( itk::ExceptionObject & excep )
     {
      MITK_ERROR << "Exception caught: " << excep.GetDescription();
 
      m_ProgressCommand->SetRemainingProgress(100);
      CurrentlyBusy.Send(false);
 
      std::string msg = excep.GetDescription();
      ErrorMessage.Send(msg);
 
      return;
     }
     m_ProgressCommand->SetRemainingProgress(100);
     CurrentlyBusy.Send(false);
 
     //make output visible
     mitk::Image::Pointer result = mitk::Image::New();
     CastToMitkImage( m_ThresholdFilter->GetOutput(), result);
     result->GetGeometry()->SetOrigin(m_ReferenceImageSlice->GetGeometry()->GetOrigin() );
     result->GetGeometry()->SetIndexToWorldTransform(m_ReferenceImageSlice->GetGeometry()->GetIndexToWorldTransform() );
     m_ResultImageNode->SetData(result);
     m_ResultImageNode->SetVisibility(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void mitk::FastMarchingTool::ClearSeeds()
 {
   // clear seeds for FastMarching as well as the PointSet for visualization
   if(this->m_SeedContainer.IsNotNull())
     this->m_SeedContainer->Initialize();
 
   if(this->m_SeedsAsPointSet.IsNotNull())
     this->m_SeedsAsPointSet->Clear();
 
   if(this->m_FastMarchingFilter.IsNotNull())
     m_FastMarchingFilter->Modified();
 
   this->m_NeedUpdate = true;
 }
 
 
 void mitk::FastMarchingTool::Reset()
 {
   //clear all seeds and preview empty result
   this->ClearSeeds();
 
   m_ResultImageNode->SetVisibility(false);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::FastMarchingTool::SetCurrentTimeStep(int t)
 {
   if( m_CurrentTimeStep != t )
   {
     m_CurrentTimeStep = t;
 
     this->Initialize();
   }
-}
+}
\ No newline at end of file
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
index 61f13409f5..5bee747a25 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
@@ -1,399 +1,399 @@
 /*===================================================================
 
 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 "mitkFastMarchingTool3D.h"
 #include "mitkToolManager.h"
 
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkInteractionConst.h"
 #include "mitkGlobalInteraction.h"
 
 #include "itkOrImageFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageCast.h"
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, FastMarchingTool3D, "FastMarching3D tool");
 }
 
 
 mitk::FastMarchingTool3D::FastMarchingTool3D()
 :/*FeedbackContourTool*/AutoSegmentationTool(),
 m_NeedUpdate(true),
 m_CurrentTimeStep(0),
 m_LowerThreshold(0),
 m_UpperThreshold(200),
 m_StoppingValue(100),
 m_Sigma(1.0),
 m_Alpha(-0.5),
 m_Beta(3.0)
 {
 }
 
 mitk::FastMarchingTool3D::~FastMarchingTool3D()
 {
 }
 
 const char** mitk::FastMarchingTool3D::GetXPM() const
 {
   return NULL;//mitkFastMarchingTool3D_xpm;
 }
 
 us::ModuleResource mitk::FastMarchingTool3D::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
   return resource;
 }
 
 const char* mitk::FastMarchingTool3D::GetName() const
 {
   return "FastMarching3D";
 }
 
 void mitk::FastMarchingTool3D::SetUpperThreshold(double value)
 {
   m_UpperThreshold = value / 10.0;
   m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool3D::SetLowerThreshold(double value)
 {
   m_LowerThreshold = value / 10.0;
   m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool3D::SetBeta(double value)
 {
   if (m_Beta != value)
   {
       m_Beta = value;
       m_SigmoidFilter->SetBeta( m_Beta );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::SetSigma(double value)
 {
   if (m_Sigma != value)
   {
       m_Sigma = value;
       m_GradientMagnitudeFilter->SetSigma( m_Sigma );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::SetAlpha(double value)
 {
   if (m_Alpha != value)
   {
       m_Alpha = value;
       m_SigmoidFilter->SetAlpha( m_Alpha );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::SetStoppingValue(double value)
 {
   if (m_StoppingValue != value)
   {
       m_StoppingValue = value;
       m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::Activated()
 {
   Superclass::Activated();
 
   m_ResultImageNode = mitk::DataNode::New();
   m_ResultImageNode->SetName("FastMarching_Preview");
   m_ResultImageNode->SetBoolProperty("helper object", true);
   m_ResultImageNode->SetColor(0.0, 1.0, 0.0);
   m_ResultImageNode->SetVisibility(true);
   m_ToolManager->GetDataStorage()->Add( this->m_ResultImageNode, m_ToolManager->GetReferenceData(0));
 
   m_SeedsAsPointSet = mitk::PointSet::New();
   m_SeedsAsPointSetNode = mitk::DataNode::New();
   m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
   m_SeedsAsPointSetNode->SetName("3D_FastMarching_PointSet");
   m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
   m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
   m_SeedsAsPointSetNode->SetVisibility(true);
   m_SeedPointInteractor = mitk::PointSetInteractor::New("PressMoveReleaseAndPointSetting", m_SeedsAsPointSetNode);
 
   m_ReferenceImageAsITK = InternalImageType::New();
 
   m_ProgressCommand = mitk::ToolCommand::New();
 
   m_ThresholdFilter = ThresholdingFilterType::New();
   m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
   m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
   m_ThresholdFilter->SetOutsideValue( 0 );
   m_ThresholdFilter->SetInsideValue( 1.0 );
 
   m_SmoothFilter = SmoothingFilterType::New();
   m_SmoothFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_SmoothFilter->SetTimeStep( 0.05 );
   m_SmoothFilter->SetNumberOfIterations( 2 );
   m_SmoothFilter->SetConductanceParameter( 9.0 );
 
   m_GradientMagnitudeFilter = GradientFilterType::New();
   m_GradientMagnitudeFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_GradientMagnitudeFilter->SetSigma( m_Sigma );
 
   m_SigmoidFilter = SigmoidFilterType::New();
   m_SigmoidFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_SigmoidFilter->SetAlpha( m_Alpha );
   m_SigmoidFilter->SetBeta( m_Beta );
   m_SigmoidFilter->SetOutputMinimum( 0.0 );
   m_SigmoidFilter->SetOutputMaximum( 1.0 );
 
   m_FastMarchingFilter = FastMarchingFilterType::New();
   m_FastMarchingFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
 
   m_SeedContainer = NodeContainer::New();
   m_SeedContainer->Initialize();
   m_FastMarchingFilter->SetTrialPoints( m_SeedContainer );
 
   //set up pipeline
   m_SmoothFilter->SetInput( m_ReferenceImageAsITK );
   m_GradientMagnitudeFilter->SetInput( m_SmoothFilter->GetOutput() );
   m_SigmoidFilter->SetInput( m_GradientMagnitudeFilter->GetOutput() );
   m_FastMarchingFilter->SetInput( m_SigmoidFilter->GetOutput() );
   m_ThresholdFilter->SetInput( m_FastMarchingFilter->GetOutput() );
 
   m_ToolManager->GetDataStorage()->Add(m_SeedsAsPointSetNode, m_ToolManager->GetWorkingData(0));
   mitk::GlobalInteraction::GetInstance()->AddInteractor(m_SeedPointInteractor);
 
   itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointAddedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
   pointAddedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnAddPoint);
   m_PointSetAddObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
 
   itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointRemovedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
   pointRemovedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnDelete);
   m_PointSetRemoveObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetRemoveEvent(), pointRemovedCommand);
 
   this->Initialize();
 }
 
 void mitk::FastMarchingTool3D::Deactivated()
 {
   Superclass::Deactivated();
   m_ToolManager->GetDataStorage()->Remove( this->m_ResultImageNode );
   m_ToolManager->GetDataStorage()->Remove( this->m_SeedsAsPointSetNode );
   this->ClearSeeds();
   this->m_SmoothFilter->RemoveAllObservers();
   this->m_SigmoidFilter->RemoveAllObservers();
   this->m_GradientMagnitudeFilter->RemoveAllObservers();
   this->m_FastMarchingFilter->RemoveAllObservers();
   m_ResultImageNode = NULL;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   unsigned int numberOfPoints = m_SeedsAsPointSet->GetSize();
   for (unsigned int i = 0; i < numberOfPoints; ++i)
   {
     mitk::Point3D point = m_SeedsAsPointSet->GetPoint(i);
     mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpREMOVE, point, 0);
     m_SeedsAsPointSet->ExecuteOperation(doOp);
   }
   mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_SeedPointInteractor);
   m_ToolManager->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
   m_SeedsAsPointSet->RemoveObserver(m_PointSetAddObserverTag);
   m_SeedsAsPointSet->RemoveObserver(m_PointSetRemoveObserverTag);
 }
 
 void mitk::FastMarchingTool3D::Initialize()
 {
   m_ReferenceImage = dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData());
-  if(m_ReferenceImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
+  if(m_ReferenceImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
     timeSelector->SetInput( m_ReferenceImage );
     timeSelector->SetTimeNr( m_CurrentTimeStep );
     timeSelector->UpdateLargestPossibleRegion();
     m_ReferenceImage = timeSelector->GetOutput();
   }
   CastToItkImage(m_ReferenceImage, m_ReferenceImageAsITK);
   m_SmoothFilter->SetInput( m_ReferenceImageAsITK );
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool3D::ConfirmSegmentation()
 {
   // combine preview image with current working segmentation
   if (dynamic_cast<mitk::Image*>(m_ResultImageNode->GetData()))
   {
     //logical or combination of preview and segmentation slice
     OutputImageType::Pointer segmentationImageInITK = OutputImageType::New();
 
     mitk::Image::Pointer workingImage = dynamic_cast<mitk::Image*>(GetTargetSegmentationNode()->GetData());
-    if(workingImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
+    if(workingImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput( workingImage );
       timeSelector->SetTimeNr( m_CurrentTimeStep );
       timeSelector->UpdateLargestPossibleRegion();
       CastToItkImage( timeSelector->GetOutput(), segmentationImageInITK );
     }
     else
     {
       CastToItkImage( workingImage, segmentationImageInITK );
     }
 
     typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
     OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
 
     orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
     orFilter->SetInput(1, segmentationImageInITK);
     orFilter->Update();
 
     //set image volume in current time step from itk image
     workingImage->SetVolume( (void*)(m_ThresholdFilter->GetOutput()->GetPixelContainer()->GetBufferPointer()), m_CurrentTimeStep);
     this->m_ResultImageNode->SetVisibility(false);
     this->ClearSeeds();
     workingImage->Modified();
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void mitk::FastMarchingTool3D::OnAddPoint()
 {
   // Add a new seed point for FastMarching algorithm
   mitk::Point3D clickInIndex;
 
   m_ReferenceImage->GetGeometry()->WorldToIndex(m_SeedsAsPointSet->GetPoint(m_SeedsAsPointSet->GetSize()-1),
                                                 clickInIndex);
   itk::Index<3> seedPosition;
   seedPosition[0] = clickInIndex[0];
   seedPosition[1] = clickInIndex[1];
   seedPosition[2] = clickInIndex[2];
 
   NodeType node;
   const double seedValue = 0.0;
   node.SetValue( seedValue );
   node.SetIndex( seedPosition );
   this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
   m_FastMarchingFilter->Modified();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   m_NeedUpdate = true;
 
   this->Update();
 }
 
 
 void mitk::FastMarchingTool3D::OnDelete()
 {
   // delete last seed point
   if(!(this->m_SeedContainer->empty()))
   {
     //delete last element of seeds container
     this->m_SeedContainer->pop_back();
     m_FastMarchingFilter->Modified();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     m_NeedUpdate = true;
 
     this->Update();
   }
 }
 
 
 void mitk::FastMarchingTool3D::Update()
 {
   if (m_NeedUpdate)
   {
     m_ProgressCommand->AddStepsToDo(200);
     CurrentlyBusy.Send(true);
     try
     {
       m_ThresholdFilter->Update();
     }
     catch( itk::ExceptionObject & excep )
     {
      MITK_ERROR << "Exception caught: " << excep.GetDescription();
 
      m_ProgressCommand->SetRemainingProgress(100);
      CurrentlyBusy.Send(false);
 
      std::string msg = excep.GetDescription();
      ErrorMessage.Send(msg);
 
      return;
     }
     m_ProgressCommand->SetRemainingProgress(100);
     CurrentlyBusy.Send(false);
 
     //make output visible
     mitk::Image::Pointer result = mitk::Image::New();
     CastToMitkImage( m_ThresholdFilter->GetOutput(), result);
     result->GetGeometry()->SetOrigin(m_ReferenceImage->GetGeometry()->GetOrigin() );
     result->GetGeometry()->SetIndexToWorldTransform(m_ReferenceImage->GetGeometry()->GetIndexToWorldTransform() );
     m_ResultImageNode->SetData(result);
     m_ResultImageNode->SetVisibility(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void mitk::FastMarchingTool3D::ClearSeeds()
 {
   // clear seeds for FastMarching as well as the PointSet for visualization
   this->m_SeedContainer->Initialize();
   this->m_SeedsAsPointSet->Clear();
 
   m_FastMarchingFilter->Modified();
 
   this->m_NeedUpdate = true;
 }
 
 
 void mitk::FastMarchingTool3D::Reset()
 {
   //clear all seeds and preview empty result
   this->ClearSeeds();
 
   m_ResultImageNode->SetVisibility(false);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::FastMarchingTool3D::SetCurrentTimeStep(int t)
 {
   if( m_CurrentTimeStep != t )
   {
     m_CurrentTimeStep = t;
 
     this->Initialize();
   }
-}
+}
\ No newline at end of file
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index 337dec9d12..14ef19969e 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,674 +1,674 @@
 /*===================================================================
 
 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 "mitkLiveWireTool2D.h"
 
 #include "mitkToolManager.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkLiveWireTool2D.xpm"
 
 #include <mitkInteractionConst.h>
 #include <mitkGlobalInteraction.h>
 
 #include "mitkContourUtils.h"
 #include "mitkContour.h"
 
 #include <itkGradientMagnitudeImageFilter.h>
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, LiveWireTool2D, "LiveWire tool");
 }
 
 
 mitk::LiveWireTool2D::LiveWireTool2D()
 :SegTool2D("LiveWireTool")
 {
 
   // great magic numbers
   CONNECT_ACTION( AcINITNEWOBJECT, OnInitLiveWire );
   CONNECT_ACTION( AcADDPOINT, OnAddPoint );
   CONNECT_ACTION( AcMOVE, OnMouseMoveNoDynamicCosts );
   CONNECT_ACTION( AcCHECKPOINT, OnCheckPoint );
   CONNECT_ACTION( AcFINISH, OnFinish );
   CONNECT_ACTION( AcDELETEPOINT, OnLastSegmentDelete );
   CONNECT_ACTION( AcADDLINE, OnMouseMoved );
 }
 
 
 
 mitk::LiveWireTool2D::~LiveWireTool2D()
 {
   this->m_WorkingContours.clear();
   this->m_EditingContours.clear();
 }
 
 
 
 float mitk::LiveWireTool2D::CanHandleEvent( StateEvent const *stateEvent) const
 {
   mitk::PositionEvent const  *positionEvent =
   dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
 
   //Key event handling:
   if (positionEvent == NULL)
   {
     //check for delete and escape event
     if(stateEvent->GetId() == 12 || stateEvent->GetId() == 14)
     {
       return 1.0;
     }
     //check, if the current state has a transition waiting for that key event.
     else if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       return 0.5;
     }
     else
     {
       return 0.0;
     }
   }
   else
   {
     if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D )
       return 0.0; // we don't want anything but 2D
 
     return 1.0;
   }
 
 }
 
 const char** mitk::LiveWireTool2D::GetXPM() const
 {
   return mitkLiveWireTool2D_xpm;
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("LiveWire_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("LiveWire_Cursor_32x32.png");
   return resource;
 }
 
 const char* mitk::LiveWireTool2D::GetName() const
 {
   return "Live Wire";
 }
 
 void mitk::LiveWireTool2D::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::LiveWireTool2D::Deactivated()
 {
   this->ClearContours();
 
   Superclass::Deactivated();
 }
 
 void mitk::LiveWireTool2D::ClearContours()
 {
   // for all contours in list (currently created by tool)
   std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator iter = this->m_WorkingContours.begin();
   while(iter != this->m_WorkingContours.end() )
   {
     //remove contour node from datastorage
     m_ToolManager->GetDataStorage()->Remove( iter->first );
 
     ++iter;
   }
 
   this->m_WorkingContours.clear();
 
   // for all contours in list (currently created by tool)
   std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator itEditingContours = this->m_EditingContours.begin();
   while(itEditingContours != this->m_EditingContours.end() )
   {
       //remove contour node from datastorage
       m_ToolManager->GetDataStorage()->Remove( itEditingContours->first );
       ++itEditingContours;
   }
 
   this->m_EditingContours.clear();
 
   std::vector< mitk::ContourModelLiveWireInteractor::Pointer >::iterator itLiveWireInteractors = this->m_LiveWireInteractors.begin();
   while(itLiveWireInteractors != this->m_LiveWireInteractors.end() )
   {
       // remove interactors from globalInteraction instance
       mitk::GlobalInteraction::GetInstance()->RemoveInteractor( *itLiveWireInteractors );
       ++itLiveWireInteractors;
   }
 
   this->m_LiveWireInteractors.clear();
 }
 
 void mitk::LiveWireTool2D::ConfirmSegmentation()
 {
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   assert ( workingNode );
 
   Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
   assert ( workingImage );
 
   ContourUtils::Pointer contourUtils = mitk::ContourUtils::New();
 
   // 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( int currentTimestep = 0; currentTimestep < contourModel->GetTimeSlicedGeometry()->GetTimeSteps(); currentTimestep++)
+        for( TimeStepType currentTimestep = 0; currentTimestep < contourModel->GetTimeGeometry()->GetNumberOfTimeSteps(); ++currentTimestep)
         {
 
           //get the segmentation image slice at current timestep
           mitk::Image::Pointer workingSlice = this->GetAffectedImageSliceAs2DImage(itWorkingContours->second, workingImage, currentTimestep);
 
           mitk::ContourModel::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice(workingSlice, contourModel, true, false);
           contourUtils->FillContourInSlice(projectedContour, workingSlice, 1.0);
 
           //write back to image volume
           this->WriteBackSegmentationResult(itWorkingContours->second, workingSlice, currentTimestep);
         }
 
         //remove contour node from datastorage
     //    m_ToolManager->GetDataStorage()->Remove( itWorkingContours->first );
       }
     }
 
     ++itWorkingContours;
   }
 /*
   this->m_WorkingContours.clear();
 
   // for all contours in list (currently created by tool)
   std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator itEditingContours = this->m_EditingContours.begin();
   while(itEditingContours != this->m_EditingContours.end() )
   {
       //remove contour node from datastorage
       m_ToolManager->GetDataStorage()->Remove( itEditingContours->first );
       ++itEditingContours;
   }
 
   this->m_EditingContours.clear();
 
   std::vector< mitk::ContourModelLiveWireInteractor::Pointer >::iterator itLiveWireInteractors = this->m_LiveWireInteractors.begin();
   while(itLiveWireInteractors != this->m_LiveWireInteractors.end() )
   {
       // remove interactors from globalInteraction instance
       mitk::GlobalInteraction::GetInstance()->RemoveInteractor( *itLiveWireInteractors );
       ++itLiveWireInteractors;
   }
 
   this->m_LiveWireInteractors.clear();
 */
   this->ClearContours();
 }
 
 bool mitk::LiveWireTool2D::OnInitLiveWire (Action* action, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   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->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(100));
   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(100));
   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 );
 
   m_ToolManager->GetDataStorage()->Add( m_ContourModelNode );
   m_ToolManager->GetDataStorage()->Add( m_LiveWireContourNode );
   m_ToolManager->GetDataStorage()->Add( m_EditingContourNode );
 
   //set current slice as input for ImageToLiveWireContourFilter
   m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
 
   m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
   m_LiveWireFilter->SetInput(m_WorkingSlice);
 
   //map click to pixel coordinates
   mitk::Point3D click = const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition());
   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 (Action* action, const StateEvent* stateEvent)
 {
   //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 */
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
   /* END check if event can be handled */
 
   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(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
 
   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( Action* action, const StateEvent* stateEvent)
 {
   //compute LiveWire segment from last control point to current mouse position
 
   // check if event can be handled
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   // actual LiveWire computation
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   m_LiveWireFilter->SetEndPoint(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
 
   m_LiveWireFilter->SetTimeStep(m_TimeStep);
   m_LiveWireFilter->Update();
 
   m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
   m_LiveWireContourNode->SetData( this->m_LiveWireContour );
 
   //render
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 bool mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(Action* action, const StateEvent* stateEvent)
 {
   //do not use dynamic cost map
   m_LiveWireFilter->SetUseDynamicCostMap(false);
   OnMouseMoved(action, stateEvent);
   m_LiveWireFilter->SetUseDynamicCostMap(true);
   return true;
 }
 
 bool mitk::LiveWireTool2D::OnCheckPoint( Action* action, const StateEvent* stateEvent)
 {
   //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
   //
 
   mitk::StateEvent* newStateEvent = NULL;
 
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent)
   {
     //stay in current state
     newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
   }
   else
   {
     int timestep = positionEvent->GetSender()->GetTimeStep();
 
     mitk::Point3D click = positionEvent->GetWorldPosition();
 
     mitk::Point3D first = this->m_Contour->GetVertexAt(0, timestep)->Coordinates;
 
     if (first.EuclideanDistanceTo(click) < 4.5)
     {
       // allow to finish
       newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
     }
     else
     {
       //stay active
       newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
     }
   }
 
   this->HandleEvent( newStateEvent );
 
   return true;
 }
 
 bool mitk::LiveWireTool2D::OnFinish( Action* action, const StateEvent* stateEvent)
 {
   // finish livewire tool interaction
 
   // check if event can be handled
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   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()) );
   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()) );
   this->m_EditingContours.push_back(ecp);
 
   m_LiveWireFilter->SetUseDynamicCostMap(false);
 
   this->FinishTool();
 
   return true;
 }
 
 void mitk::LiveWireTool2D::FinishTool()
 {
-  unsigned int numberOfTimesteps = m_Contour->GetTimeSlicedGeometry()->GetTimeSteps();
+  TimeStepType numberOfTimesteps = m_Contour->GetTimeGeometry()->GetNumberOfTimeSteps();
 
   //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;
 
   //change color as visual feedback of completed livewire
   //m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1.0, 1.0, 0.1), NULL, true );
   //m_ContourModelNode->SetName("contour node");
 
   //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( Action* action, const StateEvent* stateEvent)
 {
   int timestep = stateEvent->GetEvent()->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 );
     Superclass::Deactivated(); //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->SetIsClosed(m_Contour->IsClosed());
 
     //set new contour visible
     m_ContourModelNode->SetData(newContour);
 
     m_Contour = newContour;
 
     assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
     mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->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/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index d5cef9b0c4..32e634da53 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,402 +1,402 @@
 /*===================================================================
 
 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( StateEvent const *stateEvent) const
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return 0.0;
 
   if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D ) return 0.0; // we don't want anything but 2D
 
   //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
   Geometry3D* 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 PositionEvent* 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() ) );
 
   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->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
+  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(), slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   /*============= END undo feature block ========================*/
 
   return slice;
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const PositionEvent* 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 PositionEvent* 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 PositionEvent* positionEvent, Image* slice)
 {
   if(!positionEvent) return;
 
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
 
   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 )
     {
       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->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
+  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(),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 PositionEvent* positionEvent )
 {
   const mitk::Geometry2D* plane = dynamic_cast<const Geometry2D*> (dynamic_cast< const mitk::SlicedGeometry3D*>(
     positionEvent->GetSender()->GetSliceNavigationController()->GetCurrentGeometry3D())->GetGeometry2D(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<Geometry2D*>(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/mitkTool.cpp b/Modules/Segmentation/Interactions/mitkTool.cpp
index 30a3ed1b29..1a009699e3 100644
--- a/Modules/Segmentation/Interactions/mitkTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkTool.cpp
@@ -1,217 +1,217 @@
 /*===================================================================
 
 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 "mitkTool.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkProperties.h"
 #include "mitkImageWriteAccessor.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkImageReadAccessor.h"
 
 // us
 #include <usModuleResource.h>
 
 #include <itkObjectFactory.h>
 
 mitk::Tool::Tool(const char* type)
 : StateMachine(type),
   m_SupportRoi(false),
   // for reference images
   m_PredicateImages(NodePredicateDataType::New("Image")),
   m_PredicateDim3(NodePredicateDimension::New(3, 1)),
   m_PredicateDim4(NodePredicateDimension::New(4, 1)),
   m_PredicateDimension( mitk::NodePredicateOr::New(m_PredicateDim3, m_PredicateDim4) ),
   m_PredicateImage3D( NodePredicateAnd::New(m_PredicateImages, m_PredicateDimension) ),
 
   m_PredicateBinary(NodePredicateProperty::New("binary", BoolProperty::New(true))),
   m_PredicateNotBinary( NodePredicateNot::New(m_PredicateBinary) ),
 
   m_PredicateSegmentation(NodePredicateProperty::New("segmentation", BoolProperty::New(true))),
   m_PredicateNotSegmentation( NodePredicateNot::New(m_PredicateSegmentation) ),
 
   m_PredicateHelper(NodePredicateProperty::New("helper object", BoolProperty::New(true))),
   m_PredicateNotHelper( NodePredicateNot::New(m_PredicateHelper) ),
 
   m_PredicateImageColorful( NodePredicateAnd::New(m_PredicateNotBinary, m_PredicateNotSegmentation) ),
 
   m_PredicateImageColorfulNotHelper( NodePredicateAnd::New(m_PredicateImageColorful, m_PredicateNotHelper) ),
 
   m_PredicateReference( NodePredicateAnd::New(m_PredicateImage3D, m_PredicateImageColorfulNotHelper) ),
 
   // for working image
   m_IsSegmentationPredicate(NodePredicateAnd::New(NodePredicateOr::New(m_PredicateBinary, m_PredicateSegmentation), m_PredicateNotHelper))
 {
 }
 
 mitk::Tool::~Tool()
 {
 }
 
 const char* mitk::Tool::GetGroup() const
 {
   return "default";
 }
 
 void mitk::Tool::SetToolManager(ToolManager* manager)
 {
   m_ToolManager = manager;
 }
 
 void mitk::Tool::Activated()
 {
 }
 
 void mitk::Tool::Deactivated()
 {
   StateMachine::ResetStatemachineToStartState(); // forget about the past
 }
 
 itk::Object::Pointer mitk::Tool::GetGUI(const std::string& toolkitPrefix, const std::string& toolkitPostfix)
 {
   itk::Object::Pointer object;
 
   std::string classname = this->GetNameOfClass();
   std::string guiClassname = toolkitPrefix + classname + toolkitPostfix;
 
   std::list<itk::LightObject::Pointer> allGUIs = itk::ObjectFactoryBase::CreateAllInstance(guiClassname.c_str());
   for( std::list<itk::LightObject::Pointer>::iterator iter = allGUIs.begin();
        iter != allGUIs.end();
        ++iter )
   {
     if (object.IsNull())
     {
       object = dynamic_cast<itk::Object*>( iter->GetPointer() );
     }
     else
     {
       MITK_ERROR << "There is more than one GUI for " << classname << " (several factories claim ability to produce a " << guiClassname << " ) " << std::endl;
       return NULL; // people should see and fix this error
     }
   }
 
   return object;
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::Tool::GetReferenceDataPreference() const
 {
   return m_PredicateReference.GetPointer();
 }
 
 
 mitk::NodePredicateBase::ConstPointer mitk::Tool::GetWorkingDataPreference() const
 {
   return m_IsSegmentationPredicate.GetPointer();
 }
 
 mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode( Image* original, const std::string& organName, const mitk::Color& color )
 {
   // we NEED a reference image for size etc.
   if (!original) return NULL;
 
   // actually create a new empty segmentation
   PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>() );
   Image::Pointer segmentation = Image::New();
 
   if (original->GetDimension() == 2)
   {
     const unsigned int dimensions[] = { original->GetDimension(0), original->GetDimension(1), 1 };
     segmentation->Initialize(pixelType, 3, dimensions);
   }
   else
   {
     segmentation->Initialize(pixelType, original->GetDimension(), original->GetDimensions());
   }
 
   unsigned int byteSize = sizeof(DefaultSegmentationDataType);
 
   if(segmentation->GetDimension() < 4)
   {
     for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
     {
       byteSize *= segmentation->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor writeAccess(segmentation, segmentation->GetVolumeData(0));
 
     memset( writeAccess.GetData(), 0, byteSize );
   }
   else
   {//if we have a time-resolved image we need to set memory to 0 for each time step
     for (unsigned int dim = 0; dim < 3; ++dim)
     {
       byteSize *= segmentation->GetDimension(dim);
     }
 
     for( unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
     {
       mitk::ImageWriteAccessor writeAccess(segmentation, segmentation->GetVolumeData(volumeNumber));
 
       memset( writeAccess.GetData(), 0, byteSize );
     }
   }
 
   if (original->GetTimeSlicedGeometry() )
   {
-    TimeSlicedGeometry::Pointer originalGeometry = original->GetTimeSlicedGeometry()->Clone();
-    segmentation->SetGeometry( originalGeometry );
+    TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
+    segmentation->SetTimeGeometry( originalGeometry );
   }
   else
   {
     Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
     return NULL;
   }
 
   return CreateSegmentationNode( segmentation, organName, color );
 }
 
 mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode( Image* image, const std::string& organName, const mitk::Color& color )
 {
   if (!image) return NULL;
 
   // decorate the datatreenode with some properties
   DataNode::Pointer segmentationNode = DataNode::New();
   segmentationNode->SetData( image );
 
   // name
   segmentationNode->SetProperty( "name", StringProperty::New( organName ) );
 
   // visualization properties
   segmentationNode->SetProperty( "binary", BoolProperty::New(true) );
   segmentationNode->SetProperty( "color", ColorProperty::New(color) );
   segmentationNode->SetProperty( "texture interpolation", BoolProperty::New(false) );
   segmentationNode->SetProperty( "layer", IntProperty::New(10) );
   segmentationNode->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow(0.5, 1) ) );
   segmentationNode->SetProperty( "opacity", FloatProperty::New(0.3) );
   segmentationNode->SetProperty( "segmentation", BoolProperty::New(true) );
   segmentationNode->SetProperty( "reslice interpolation", VtkResliceInterpolationProperty::New() ); // otherwise -> segmentation appears in 2 slices sometimes (only visual effect, not different data)
   // For MITK-3M3 release, the volume of all segmentations should be shown
   segmentationNode->SetProperty( "showVolume", BoolProperty::New( true ) );
 
   return segmentationNode;
 }
 
 us::ModuleResource mitk::Tool::GetIconResource() const
 {
   // Each specific tool should load its own resource. This one will be invalid
   return us::ModuleResource();
 }
 
 us::ModuleResource mitk::Tool::GetCursorIconResource() const
 {
   // Each specific tool should load its own resource. This one will be invalid
   return us::ModuleResource();
-}
+}
\ No newline at end of file
diff --git a/Modules/Segmentation/Rendering/mitkContourModelMapper2D.cpp b/Modules/Segmentation/Rendering/mitkContourModelMapper2D.cpp
index cbdfcbce77..cd7258329a 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelMapper2D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourModelMapper2D.cpp
@@ -1,390 +1,390 @@
 /*===================================================================
 
 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 <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->SetInput(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 TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
+    const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
-    || ( dataTimeGeometry->GetTimeSteps() == 0 )
-    || ( !dataTimeGeometry->IsValidTime( renderer->GetTimeStep() ) ) )
+    || ( dataTimeGeometry->GetNumberOfTimeSteps() == 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 < 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::Geometry2D*>(renderer->GetCurrentWorldGeometry2D()));
 
   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->AddInput(sphere->GetOutput());
           }
         }
 
 
         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->AddInput(sphere->GetOutput());
         }
       }
 
 
       /* 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->SetInput(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->AddInput(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/Segmentation/Rendering/mitkContourModelMapper3D.cpp b/Modules/Segmentation/Rendering/mitkContourModelMapper3D.cpp
index 28029b62e3..d3a112c671 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelMapper3D.cpp
+++ b/Modules/Segmentation/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->SetInput(localStorage->m_OutlinePolyData);
 
   float lineWidth(1.0);
   if (this->GetDataNode()->GetFloatProperty( "3D contour 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->SetInput(localStorage->m_TubeFilter->GetOutput());
 
 }
 
 
 
 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 TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
+  const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
-    || ( dataTimeGeometry->GetTimeSteps() == 0 )
-    || ( !dataTimeGeometry->IsValidTime( renderer->GetTimeStep() ) )
+    || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 )
+    || ( !dataTimeGeometry->IsValidTimeStep( renderer->GetTimeStep() ) )
     || ( this->GetTimestep() == -1 ) )
   {
     //clear the rendered polydata
     localStorage->m_Mapper->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 < 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
         ("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( "3D contour width", mitk::FloatProperty::New( 0.5 ), renderer, overwrite );
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
index 5e37dc572e..0516d1714f 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
@@ -1,839 +1,834 @@
 /*===================================================================
 
 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 "QmitkAdaptiveRegionGrowingToolGUI.h"
 
 #include "QmitkStdMultiWidget.h"
 
 #include <qmessagebox.h>
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkPointSetInteractor.h"
 #include "mitkProperties.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkImageTimeSelector.h"
 
 #include "mitkImageStatisticsHolder.h"
 
 #include <itkConnectedAdaptiveThresholdImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkImageIterator.h>
 
 #include "itkOrImageFilter.h"
 #include "mitkImageCast.h"
 #include "QmitkConfirmSegmentationDialog.h"
 
 
 MITK_TOOL_GUI_MACRO( , QmitkAdaptiveRegionGrowingToolGUI, "")
 
 QmitkAdaptiveRegionGrowingToolGUI::QmitkAdaptiveRegionGrowingToolGUI(QWidget* parent) :
 QmitkToolGUI(), m_MultiWidget(NULL), m_UseVolumeRendering(false), m_UpdateSuggestedThreshold(true), m_SuggestedThValue(0.0), m_DataStorage(NULL)
 {
   this->setParent(parent);
 
   m_Controls.setupUi(this);
 
   m_Controls.m_ThresholdSlider->setDecimals(1);
   m_Controls.m_ThresholdSlider->setSpinBoxAlignment(Qt::AlignVCenter);
 
   m_Controls.m_PreviewSlider->setEnabled(false);
   m_Controls.m_PreviewSlider->setSingleStep(0.5);
   //Not yet available
   //m_Controls.m_PreviewSlider->InvertedAppearance(true);
 
   this->CreateConnections();
   this->SetDataNodeNames("labeledRGSegmentation","RGResult","RGFeedbackSurface");
 
   connect( this, SIGNAL(NewToolAssociated(mitk::Tool*)), this, SLOT(OnNewToolAssociated(mitk::Tool*)) );
 }
 
 
 
 QmitkAdaptiveRegionGrowingToolGUI::~QmitkAdaptiveRegionGrowingToolGUI()
 {
     //Removing the observer of the PointSet node
     if (m_RegionGrow3DTool->GetPointSetNode().IsNotNull())
     {
         m_RegionGrow3DTool->GetPointSetNode()->GetData()->RemoveObserver(m_PointSetAddObserverTag);
     }
     this->RemoveHelperNodes();
 }
 
 
 void QmitkAdaptiveRegionGrowingToolGUI::OnNewToolAssociated(mitk::Tool* tool)
 {
   m_RegionGrow3DTool = dynamic_cast<mitk::AdaptiveRegionGrowingTool*> (tool);
   if(m_RegionGrow3DTool.IsNotNull())
   {
     SetInputImageNode( this->m_RegionGrow3DTool->GetReferenceData() );
     this->m_DataStorage = this->m_RegionGrow3DTool->GetDataStorage();
     this->EnableControls(true);
 
     //Watch for point added or modified
     itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::Pointer pointAddedCommand = itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::New();
     pointAddedCommand->SetCallbackFunction(this, &QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded);
     m_PointSetAddObserverTag = m_RegionGrow3DTool->GetPointSetNode()->GetData()->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
   }
   else
   {
     this->EnableControls(false);
   }
 }
 
 
 void QmitkAdaptiveRegionGrowingToolGUI::RemoveHelperNodes()
 {
   mitk::DataNode::Pointer imageNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if( imageNode.IsNotNull() )
   {
     m_DataStorage->Remove(imageNode);
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::CreateConnections()
 {
     //Connecting GUI components
     connect( (QObject*) (m_Controls.m_pbRunSegmentation), SIGNAL(clicked()), this, SLOT(RunSegmentation()));
     connect( m_Controls.m_PreviewSlider, SIGNAL(valueChanged(double)), this, SLOT(ChangeLevelWindow(double)));
     connect( (QObject*) (m_Controls.m_pbConfirmSegementation), SIGNAL(clicked()), this, SLOT(ConfirmSegmentation()));
     connect( (QObject*) (m_Controls.m_cbVolumeRendering), SIGNAL(toggled(bool)), this, SLOT(UseVolumeRendering(bool) ));
     connect( m_Controls.m_ThresholdSlider, SIGNAL(maximumValueChanged(double)), this, SLOT(SetUpperThresholdValue(double)));
     connect( m_Controls.m_ThresholdSlider, SIGNAL(minimumValueChanged(double)), this, SLOT(SetLowerThresholdValue(double)));
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetDataNodeNames(std::string labledSegmentation, std::string binaryImage, std::string surface)
 {
   m_NAMEFORLABLEDSEGMENTATIONIMAGE = labledSegmentation;
   m_NAMEFORBINARYIMAGE = binaryImage;
   m_NAMEFORSURFACE = surface;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
 {
   m_MultiWidget = multiWidget;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetInputImageNode(mitk::DataNode* node)
 {
   m_InputImageNode = node;
   mitk::Image* inputImage = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
   if (inputImage)
   {
     mitk::ScalarType max = inputImage->GetStatistics()->GetScalarValueMax();
     mitk::ScalarType min = inputImage->GetStatistics()->GetScalarValueMin();
     m_Controls.m_ThresholdSlider->setMaximum(max);
     m_Controls.m_ThresholdSlider->setMinimum(min);
     // Just for initialization
     m_Controls.m_ThresholdSlider->setMaximumValue(max);
     m_Controls.m_ThresholdSlider->setMinimumValue(min);
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded()
 {
   if (m_RegionGrow3DTool.IsNull())
     return;
 
   mitk::DataNode* node = m_RegionGrow3DTool->GetPointSetNode();
 
   if (node != NULL)
   {
       mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
 
       if (pointSet.IsNull())
       {
           QMessageBox::critical(NULL, "QmitkAdaptiveRegionGrowingToolGUI", "PointSetNode does not contain a pointset");
           return;
       }
 
       m_Controls.m_lblSetSeedpoint->setText("");
 
       mitk::Image* image = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
 
       mitk::Point3D seedPoint = pointSet->GetPointSet(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep())->GetPoints()->ElementAt(0);
 
       m_SeedpointValue = image->GetPixelValueByWorldCoordinate(seedPoint);
 
       /* In this case the seedpoint is placed e.g. in the lung or bronchialtree
        * The lowerFactor sets the windowsize depending on the regiongrowing direction
        */
       m_CurrentRGDirectionIsUpwards = true;
       if (m_SeedpointValue < -500)
       {
           m_CurrentRGDirectionIsUpwards = false;
       }
 
       // Initializing the region by the area around the seedpoint
       m_SeedPointValueMean = 0;
 
       mitk::Index3D currentIndex, runningIndex;
       mitk::ScalarType pixelValues[125];
       unsigned int pos (0);
 
       image->GetGeometry(0)->WorldToIndex(seedPoint, currentIndex);
       runningIndex = currentIndex;
 
       for(int i = runningIndex[0]-2; i <= runningIndex[0]+2; i++)
       {
         for(int j = runningIndex[1]-2; j <= runningIndex[1]+2; j++)
         {
           for(int k = runningIndex[2]-2; k <= runningIndex[2]+2; k++)
           {
             currentIndex[0] = i;
             currentIndex[1] = j;
             currentIndex[2] = k;
 
             if(image->GetGeometry()->IsIndexInside(currentIndex))
             {
               pixelValues[pos] = image->GetPixelValueByIndex(currentIndex);
               pos++;
             }
             else
             {
               pixelValues[pos] = -10000000;
               pos++;
             }
           }
         }
       }
 
       //Now calculation mean of the pixelValues
       unsigned int numberOfValues(0);
       for (unsigned int i = 0; i < 125; i++)
       {
         if(pixelValues[i] > -10000000)
         {
           m_SeedPointValueMean += pixelValues[i];
           numberOfValues++;
         }
       }
 
       m_SeedPointValueMean = m_SeedPointValueMean/numberOfValues;
 
       /*
        * Here the upper- and lower threshold is calculated:
        * The windowSize is 20% of the maximum range of the intensity values existing in the current image
        * If the RG direction is upwards the lower TH is meanSeedValue-0.15*windowSize and upper TH is meanSeedValue+0.85*windowsSize
        * if the RG direction is downwards the lower TH is meanSeedValue-0.85*windowSize and upper TH is meanSeedValue+0.15*windowsSize
       */
       mitk::ScalarType min = image->GetStatistics()->GetScalarValueMin();
       mitk::ScalarType max = image->GetStatistics()->GetScalarValueMax();
       mitk::ScalarType windowSize = max - min;
 
       windowSize = 0.15*windowSize;
 
       if (m_CurrentRGDirectionIsUpwards)
       {
         m_LOWERTHRESHOLD = m_SeedPointValueMean;
         if (m_SeedpointValue < m_SeedPointValueMean)
           m_LOWERTHRESHOLD = m_SeedpointValue;
         m_UPPERTHRESHOLD = m_SeedpointValue + windowSize;
         if (m_UPPERTHRESHOLD > max)
           m_UPPERTHRESHOLD = max;
         m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
         m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
       }
       else
       {
         m_UPPERTHRESHOLD = m_SeedPointValueMean;
         if (m_SeedpointValue > m_SeedPointValueMean)
           m_UPPERTHRESHOLD = m_SeedpointValue;
         m_LOWERTHRESHOLD = m_SeedpointValue - windowSize;
         if (m_LOWERTHRESHOLD < min)
           m_LOWERTHRESHOLD = min;
         m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
         m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
       }
   }
 }
 
 
 
 void QmitkAdaptiveRegionGrowingToolGUI::RunSegmentation()
 {
-
   if (m_InputImageNode.IsNull())
   {
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please specify the image in Datamanager!");
     return;
   }
 
   mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
 
   if (node.IsNull())
   {
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please insert a seed point inside the image.\n\nFirst press the \"Define Seed Point\" button,\nthen click left mouse button inside the image.");
     return;
   }
 
   //safety if no pointSet or pointSet empty
   mitk::PointSet::Pointer seedPointSet = dynamic_cast<mitk::PointSet*> (node->GetData());
   if (seedPointSet.IsNull())
   {
     m_Controls.m_pbRunSegmentation->setEnabled(true);
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
     return;
   }
 
   int timeStep = mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep();
 
   if (!(seedPointSet->GetSize(timeStep)))
   {
     m_Controls.m_pbRunSegmentation->setEnabled(true);
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
     return;
   }
 
 
   mitk::PointSet::PointType seedPoint = seedPointSet->GetPointSet(timeStep)->GetPoints()->Begin().Value();
 
   mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
 
   if (orgImage.IsNotNull())
   {
       if (orgImage->GetDimension() == 4)
       {
           mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
           timeSelector->SetInput(orgImage);
           timeSelector->SetTimeNr( timeStep );
           timeSelector->UpdateLargestPossibleRegion();
           mitk::Image* timedImage = timeSelector->GetOutput();
           AccessByItk_2( timedImage , StartRegionGrowing, timedImage->GetGeometry(), seedPoint);
       }
       else if (orgImage->GetDimension() == 3)
       {
           QApplication::setOverrideCursor(QCursor(Qt::WaitCursor)); //set the cursor to waiting
           AccessByItk_2(orgImage, StartRegionGrowing, orgImage->GetGeometry(), seedPoint);
           QApplication::restoreOverrideCursor();//reset cursor
       }
       else
       {
           QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Only images of dimension 3 or 4 can be processed!");
           return;
       }
   }
   EnableControls(true); // Segmentation ran successfully, so enable all controls.
   node->SetVisibility(true);
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void QmitkAdaptiveRegionGrowingToolGUI::StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Geometry3D* imageGeometry, mitk::PointSet::PointType seedPoint)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef typename InputImageType::IndexType IndexType;
   typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
   typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
   typedef itk::MinimumMaximumImageCalculator<InputImageType> MinMaxValueFilterType;
 
   if ( !imageGeometry->IsInside(seedPoint) )
   {
     QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
     QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside of the image! Please choose a position inside the image!");
     return;
   }
 
   IndexType seedIndex;
   imageGeometry->WorldToIndex( seedPoint, seedIndex);// convert world coordinates to image indices
 
 
 
   if (m_SeedpointValue>m_UPPERTHRESHOLD || m_SeedpointValue<m_LOWERTHRESHOLD)
   {
     QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
     QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside the defined thresholds! Please set a new seed point or adjust the thresholds.");
     MITK_INFO << "Mean: " <<m_SeedPointValueMean;
     return;
   }
 
   //Setting the direction of the regiongrowing. For dark structures e.g. the lung the regiongrowing
   //is performed starting at the upper value going to the lower one
   regionGrower->SetGrowingDirectionIsUpwards( m_CurrentRGDirectionIsUpwards );
   regionGrower->SetInput( itkImage );
   regionGrower->AddSeed( seedIndex );
   //In some cases we have to subtract 1 for the lower threshold and add 1 to the upper.
   //Otherwise no region growing is done. Maybe a bug in the ConnectiveAdaptiveThresholdFilter
   regionGrower->SetLower( m_LOWERTHRESHOLD-1 );
   regionGrower->SetUpper( m_UPPERTHRESHOLD+1);
 
   try
   {
     regionGrower->Update();
   }
     catch(itk::ExceptionObject &exc)
   {
     QMessageBox errorInfo;
     errorInfo.setWindowTitle("Adaptive RG Segmentation Functionality");
     errorInfo.setIcon(QMessageBox::Critical);
     errorInfo.setText("An error occurred during region growing!");
     errorInfo.setDetailedText(exc.what());
     errorInfo.exec();
     return; // can't work
   }
   catch( ... )
   {
     QMessageBox::critical( NULL, "Adaptive RG Segmentation Functionality", "An error occurred during region growing!");
     return;
   }
 
   mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
   //initialize slider
   m_Controls.m_PreviewSlider->setMinimum(m_LOWERTHRESHOLD);
   mitk::ScalarType max = m_LOWERTHRESHOLD+resultImage->GetStatistics()->GetScalarValueMax();
   if (max < m_UPPERTHRESHOLD)
     m_Controls.m_PreviewSlider->setMaximum(max);
   else
     m_Controls.m_PreviewSlider->setMaximum(m_UPPERTHRESHOLD);
 
   this->m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
 
   if(m_CurrentRGDirectionIsUpwards)
   {
     m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean-1);
   }
   else
   {
     m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean+1);
   }
   this->m_SliderInitialized = true;
 
   //create new node and then delete the old one if there is one
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetData( resultImage );
 
   // set some properties
   newNode->SetProperty("name", mitk::StringProperty::New(m_NAMEFORLABLEDSEGMENTATIONIMAGE));
   newNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   newNode->SetProperty("color", mitk::ColorProperty::New(0.0,1.0,0.0));
   newNode->SetProperty("layer", mitk::IntProperty::New(1));
   newNode->SetProperty("opacity", mitk::FloatProperty::New(0.7));
 
   //delete the old image, if there was one:
   mitk::DataNode::Pointer binaryNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   m_DataStorage->Remove(binaryNode);
 
   // now add result to data tree
   m_DataStorage->Add( newNode, m_InputImageNode );
 
   this->InitializeLevelWindow();
 
   if(m_UseVolumeRendering)
     this->EnableVolumeRendering(true);
 
   m_UpdateSuggestedThreshold = true;// reset first stored threshold value
   //Setting progress to finished
   mitk::ProgressBar::GetInstance()->Progress(357);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::InitializeLevelWindow()
 {
   //get the preview from the datatree
   mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
 
   mitk::LevelWindow tempLevelWindow;
   newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow");
 
   mitk::ScalarType* level = new mitk::ScalarType(0.0);
   mitk::ScalarType* window = new mitk::ScalarType(1.0);
 
   int upper;
   if (m_CurrentRGDirectionIsUpwards)
   {
     upper = m_UPPERTHRESHOLD - m_SeedpointValue;
   }
   else
   {
     upper = m_SeedpointValue - m_LOWERTHRESHOLD;
   }
 
   tempLevelWindow.SetRangeMinMax(mitk::ScalarType(0), mitk::ScalarType(upper));
 
   //get the suggested threshold from the detected leakage-point and adjust the slider
 
   if (m_CurrentRGDirectionIsUpwards)
   {
     this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
     *level = m_UPPERTHRESHOLD - (m_SeedpointValue) + 0.5;
   }
   else
   {
     this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
     *level = (m_SeedpointValue) - m_LOWERTHRESHOLD + 0.5;
   }
 
   tempLevelWindow.SetLevelWindow(*level, *window);
   newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
   //update the widgets
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   m_SliderInitialized = true;
 
   //inquiry need to fix bug#1828
   static int lastSliderPosition = 0;
   if ((this->m_SeedpointValue + this->m_DetectedLeakagePoint - 1) == lastSliderPosition)
   {
     this->ChangeLevelWindow(lastSliderPosition);
   }
   lastSliderPosition = this->m_SeedpointValue + this->m_DetectedLeakagePoint-1;
 
   if(m_MultiWidget)
   {
     this->m_MultiWidget->levelWindowWidget->GetManager()->SetAutoTopMostImage(false);
     this->m_MultiWidget->levelWindowWidget->GetManager()->SetLevelWindowProperty(static_cast<mitk::LevelWindowProperty*>(newNode->GetProperty("levelwindow")));
   }
 
   if (m_UseVolumeRendering)
   this->UpdateVolumeRenderingThreshold((int) (*level + 0.5));//lower threshold for labeled image
-
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::ChangeLevelWindow(double newValue)
 {
   if (m_SliderInitialized)
   {
     //do nothing, if no preview exists
     mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
     if (newNode.IsNull())
       return;
 
     mitk::LevelWindow tempLevelWindow;
 
     newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow"); //get the levelWindow associated with the preview
 
     mitk::ScalarType level;// = this->m_UPPERTHRESHOLD - newValue + 0.5;
     mitk::ScalarType* window = new mitk::ScalarType(1);
 
     //adjust the levelwindow according to the position of the slider (newvalue)
     if (m_CurrentRGDirectionIsUpwards)
     {
       level = m_UPPERTHRESHOLD - newValue + 0.5;
       tempLevelWindow.SetLevelWindow(level, *window);
     }
     else
     {
       level = newValue - m_LOWERTHRESHOLD +0.5;
       tempLevelWindow.SetLevelWindow(level, *window);
     }
 
     newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
 
     if (m_UseVolumeRendering)
     this->UpdateVolumeRenderingThreshold((int) (level - 0.5));//lower threshold for labeled image
     newNode->SetVisibility(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::DecreaseSlider()
 {
   //moves the slider one step to the left, when the "-"-button is pressed
   if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->minimum())
   {
     int newValue = this->m_Controls.m_PreviewSlider->value() - 1;
     this->ChangeLevelWindow(newValue);
     this->m_Controls.m_PreviewSlider->setValue(newValue);
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::IncreaseSlider()
 {
   //moves the slider one step to the right, when the "+"-button is pressed
   if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->maximum())
   {
     int newValue = this->m_Controls.m_PreviewSlider->value() + 1;
     this->ChangeLevelWindow(newValue);
     this->m_Controls.m_PreviewSlider->setValue(newValue);
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::ConfirmSegmentation()
 {
   //get image node
   if(m_InputImageNode.IsNull())
   {
     QMessageBox::critical( NULL, "Adaptive region growing functionality", "Please specify the image in Datamanager!");
     return;
   }
   //get image data
   mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
   if(orgImage.IsNull())
   {
     QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Image found!");
     return;
   }
   //get labeled segmentation
   mitk::Image::Pointer labeledSeg = (mitk::Image*)m_DataStorage->GetNamedObject<mitk::Image>(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if(labeledSeg.IsNull())
   {
     QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Segmentation Preview found!");
     return;
   }
 
   mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if (newNode.IsNull())
     return;
 
   QmitkConfirmSegmentationDialog dialog;
   QString segName = QString::fromStdString(m_RegionGrow3DTool->GetCurrentSegmentationName());
 
   dialog.SetSegmentationName(segName);
   int result = dialog.exec();
 
   switch(result)
   {
   case QmitkConfirmSegmentationDialog::CREATE_NEW_SEGMENTATION:
     m_RegionGrow3DTool->SetOverwriteExistingSegmentation(false);
     break;
   case QmitkConfirmSegmentationDialog::OVERWRITE_SEGMENTATION:
     m_RegionGrow3DTool->SetOverwriteExistingSegmentation(true);
     break;
   case QmitkConfirmSegmentationDialog::CANCEL_SEGMENTATION:
     return;
   }
 
 
   mitk::Image* img = dynamic_cast<mitk::Image*>(newNode->GetData());
   AccessByItk(img, ITKThresholding);
 
   // disable volume rendering preview after the segmentation node was created
   this->EnableVolumeRendering(false);
   newNode->SetVisibility(false);
   m_Controls.m_cbVolumeRendering->setChecked(false);
   //TODO disable slider etc...
-
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void QmitkAdaptiveRegionGrowingToolGUI::ITKThresholding(itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::Image::Pointer originalSegmentation = dynamic_cast<mitk::Image*>(this->m_RegionGrow3DTool->
                                                                          GetTargetSegmentationNode()->GetData());
 
   int timeStep = mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep();
 
   if (originalSegmentation)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::Image<unsigned char, VImageDimension> SegmentationType;
 
 
     //select single 3D volume if we have more than one time step
     typename SegmentationType::Pointer originalSegmentationInITK = SegmentationType::New();
-    if(originalSegmentation->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
+    if(originalSegmentation->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput( originalSegmentation );
       timeSelector->SetTimeNr( timeStep );
       timeSelector->UpdateLargestPossibleRegion();
       CastToItkImage( timeSelector->GetOutput(), originalSegmentationInITK );
     }
     else //use original
     {
       CastToItkImage( originalSegmentation, originalSegmentationInITK );
     }
 
     //Fill current preiview image in segmentation image
     originalSegmentationInITK->FillBuffer(0);
     itk::ImageRegionIterator<SegmentationType> itOutput( originalSegmentationInITK, originalSegmentationInITK->GetLargestPossibleRegion() );
     itk::ImageRegionIterator<InputImageType> itInput( itkImage, itkImage->GetLargestPossibleRegion() );
     itOutput.GoToBegin();
     itInput.GoToBegin();
 
     //calculate threhold from slider value
     int currentTreshold = 0;
     if (m_CurrentRGDirectionIsUpwards)
     {
       currentTreshold = m_UPPERTHRESHOLD - m_Controls.m_PreviewSlider->value() + 1;
     }
     else
     {
       currentTreshold = m_Controls.m_PreviewSlider->value() - m_LOWERTHRESHOLD;
     }
 
     //iterate over image and set pixel in segmentation according to thresholded labeled image
     while( !itOutput.IsAtEnd() && !itInput.IsAtEnd() )
     {
       //Use threshold slider to determine if pixel is set to 1
       if( itInput.Value() != 0 && itInput.Value() > currentTreshold )
       {
         itOutput.Set( 1 );
       }
 
       ++itOutput;
       ++itInput;
     }
 
 
     //combine current working segmentation image with our region growing result
     originalSegmentation->SetVolume( (void*)(originalSegmentationInITK->GetPixelContainer()->GetBufferPointer()), timeStep);
 
     originalSegmentation->Modified();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::EnableControls(bool enable)
 {
   if (m_RegionGrow3DTool.IsNull())
     return;
 
   // Check if seed point is already set, if not leave RunSegmentation disabled
   //if even m_DataStorage is NULL leave node NULL
   mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
   if (node.IsNull()) {
     this->m_Controls.m_pbRunSegmentation->setEnabled(false);
   }
   else
   {
     this->m_Controls.m_pbRunSegmentation->setEnabled(enable);
   }
 
   // Check if a segmentation exists, if not leave segmentation dependent disabled.
   //if even m_DataStorage is NULL leave node NULL
   node = m_DataStorage?m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE):NULL;
   if (node.IsNull())
   {
       this->m_Controls.m_PreviewSlider->setEnabled(false);
       this->m_Controls.m_pbConfirmSegementation->setEnabled(false);
   }
   else
   {
       this->m_Controls.m_PreviewSlider->setEnabled(enable);
       this->m_Controls.m_pbConfirmSegementation->setEnabled(enable);
   }
 
   this->m_Controls.m_cbVolumeRendering->setEnabled(enable);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::EnableVolumeRendering(bool enable)
 {
   mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
 
   if(node.IsNull())
     return;
 
   if(m_MultiWidget)
      m_MultiWidget->SetWidgetPlanesVisibility(!enable);
 
 
   if (enable)
   {
     node->SetBoolProperty("volumerendering", enable);
     node->SetBoolProperty("volumerendering.uselod", true);
   }
   else
   {
     node->SetBoolProperty("volumerendering", enable);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::UpdateVolumeRenderingThreshold(int thValue)
 {
   mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
 
   mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
 
   if (m_UpdateSuggestedThreshold)
   {
     m_SuggestedThValue = thValue;
     m_UpdateSuggestedThreshold = false;
   }
 
   // grayvalue->opacity
   {
     vtkPiecewiseFunction *f = tf->GetScalarOpacityFunction();
     f->RemoveAllPoints();
     f->AddPoint(0, 0);
     f->AddPoint(thValue+0.5, 0);
     f->AddPoint(thValue+1.5, 1);
     f->AddPoint(1000, 1);
     f->ClampingOn();
     f->Modified();
   }
 
   // grayvalue->color
   {
     float a = 255.0;
     vtkColorTransferFunction *ctf = tf->GetColorTransferFunction();
     ctf->RemoveAllPoints();
     //ctf->AddRGBPoint(-1000, 0.0, 0.0, 0.0);
     ctf->AddRGBPoint(m_SuggestedThValue+1, 203/a, 104/a, 102/a);
     ctf->AddRGBPoint(m_SuggestedThValue, 255/a, 0/a, 0/a);
     ctf->ClampingOn();
     ctf->Modified();
   }
 
   // GradientOpacityFunction
   {
     vtkPiecewiseFunction *gof = tf->GetGradientOpacityFunction();
     gof->RemoveAllPoints();
     gof->AddPoint(-10000, 1);
     gof->AddPoint(10000, 1);
     gof->ClampingOn();
     gof->Modified();
   }
 
   mitk::TransferFunctionProperty::Pointer tfp = mitk::TransferFunctionProperty::New();
   tfp->SetValue(tf);
   node->SetProperty("TransferFunction", tfp);
-
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::UseVolumeRendering(bool on)
 {
   m_UseVolumeRendering = on;
 
   this->EnableVolumeRendering(on);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetLowerThresholdValue( double lowerThreshold )
 {
   m_LOWERTHRESHOLD = lowerThreshold;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetUpperThresholdValue( double upperThreshold)
 {
   m_UPPERTHRESHOLD = upperThreshold;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::Deactivated()
 {
   // make the segmentation preview node invisible
   mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if( node.IsNotNull() )
   {
     node->SetVisibility(false);
   }
 
   // disable volume rendering preview after the segmentation node was created
   this->EnableVolumeRendering(false);
   m_Controls.m_cbVolumeRendering->setChecked(false);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::Activated()
 {
-
-}
+}
\ No newline at end of file
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
index ca93eca199..572a816c49 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
@@ -1,1031 +1,1030 @@
 /*===================================================================
 
 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 <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->GetRenderer()->GetName()),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("Apply", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApply2D);
 
   m_BtnApplyForAllSlices2D = new QPushButton("Apply for all slices", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApplyForAllSlices2D);
 
   m_BtnApply3D = new QPushButton("Apply", 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::TimeSlicedGeometryEvent(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;
 }
 
 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);
       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);
       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());
   }
   //Updating the current selected segmentation for the 3D interpolation
   SetCurrentContourListID();
 
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated( true ); // re-initialize if needed
   }
 }
 
 void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
 {
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated( true ); // re-initialize if needed
   }
   if (m_3DInterpolationEnabled)
   {
     this->Show3DInterpolationResult(false);
   }
 }
 
 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::TimeSlicedGeometry* tsg = event.GetTimeSlicedGeometry();
+    mitk::TimeGeometry* tsg = event.GetTimeGeometry();
     if (tsg && m_TimeStep.contains(slicer))
     {
-      mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(tsg->GetGeometry3D(m_TimeStep[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() ));
         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->GetTimeSlicedGeometry()->GetGeometry3D( timestep ) );
+    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 );
 
     // Set all pixels to zero
     mitk::PixelType pixelType( mitk::MakeScalarPixelType<unsigned char>()  );
     memset( diffImage->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->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
+        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 << "Accept 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;
 
   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->IsSelected() &&
              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::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
-      if (timeSlicedGeometry)
+      const mitk::TimeGeometry* timeGeometry = dynamic_cast<const mitk::TimeGeometry*>( renderer->GetWorldGeometry() );
+      if (timeGeometry)
       {
-        mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeSlicedGeometry*>(timeSlicedGeometry), renderer->GetSlice() );
+        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);
 
         m_SurfaceInterpolator->SetCurrentSegmentationInterpolationList(dynamic_cast<mitk::Image*>(workingNode->GetData()));
 
         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::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);
   }
-}
+}
\ No newline at end of file
diff --git a/Modules/Simulation/mitkSimulation.cpp b/Modules/Simulation/mitkSimulation.cpp
index 1cc4e05103..ab952aed12 100644
--- a/Modules/Simulation/mitkSimulation.cpp
+++ b/Modules/Simulation/mitkSimulation.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 "mitkSimulation.h"
 #include "mitkSimulationPropAssemblyVisitor.h"
 #include <mitkDataNode.h>
 #include <mitkSurface.h>
 #include <sofa/core/visual/VisualParams.h>
 #include <sofa/simulation/tree/TreeSimulation.h>
 #include <vtkActor.h>
 #include <vtkAppendPolyData.h>
 #include <vtkMapper.h>
 #include <vtkPolyData.h>
 #include <vtkPropAssembly.h>
 #include <vtkPropCollection.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 
 const float mitk::Simulation::ScaleFactor = 1.0f; // 1000.0f
 
 static sofa::simulation::Simulation::SPtr CreateSimulation()
 {
   const std::string key = "MultiMappingObject";
 
   if (sofa::simulation::xml::BaseElement::NodeFactory::HasKey(key))
     sofa::simulation::xml::BaseElement::NodeFactory::ResetEntry(key);
 
   return sofa::core::objectmodel::New<sofa::simulation::tree::TreeSimulation>();
 }
 
 void mitk::Simulation::SetActiveSimulation(mitk::Simulation* simulation)
 {
   if (simulation == NULL)
   {
     sofa::simulation::setSimulation(NULL);
     sofa::core::visual::VisualParams::defaultInstance()->drawTool() = NULL;
   }
   else
   {
     sofa::simulation::Simulation* sofaSimulation = simulation->m_Simulation.get();
 
     if (sofa::simulation::getSimulation() != sofaSimulation)
     {
       sofa::simulation::setSimulation(sofaSimulation);
       sofa::core::visual::VisualParams::defaultInstance()->drawTool() = &simulation->m_DrawTool;
     }
   }
 }
 
 mitk::Simulation::Simulation()
   : m_Simulation(CreateSimulation()),
     m_DefaultDT(0.0)
 {
 }
 
 mitk::Simulation::~Simulation()
 {
   if (m_Simulation != NULL)
   {
     if (m_RootNode != NULL)
       m_Simulation->unload(m_RootNode);
 
     if (sofa::simulation::getSimulation() == m_Simulation.get())
       SetActiveSimulation(NULL);
   }
 }
 
 bool mitk::Simulation::AppendSnapshot(mitk::Surface::Pointer surface) const
 {
   if (surface.IsNotNull())
   {
     vtkSmartPointer<vtkPolyData> snapshot = this->CreateSnapshot();
 
     if (snapshot != NULL)
     {
       unsigned int timeStep = surface->GetSizeOfPolyDataSeries();
 
       if (timeStep != 0 && surface->GetVtkPolyData(timeStep - 1) == NULL)
         --timeStep;
 
       surface->SetVtkPolyData(snapshot, timeStep);
 
       return true;
     }
   }
 
   return false;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::Simulation::CreateSnapshot() const
 {
   if (m_RootNode == NULL)
     return NULL;
 
   vtkSmartPointer<vtkPropAssembly> propAssembly = vtkSmartPointer<vtkPropAssembly>::New();
   SimulationPropAssemblyVisitor propAssemblyVisitor(propAssembly);
 
   m_RootNode->executeVisitor(&propAssemblyVisitor);
 
   vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
 
   vtkPropCollection* propCollection = propAssembly->GetParts();
   vtkProp* prop = NULL;
 
   if (propCollection->GetNumberOfItems() == 0)
     return NULL;
 
   for (propCollection->InitTraversal(); (prop = propCollection->GetNextProp()) != NULL; )
   {
     vtkActor* actor = vtkActor::SafeDownCast(prop);
     vtkPolyData* polyData = vtkPolyData::SafeDownCast(actor->GetMapper()->GetInput());
 
     appendFilter->AddInput(polyData);
   }
 
   vtkSmartPointer<vtkTransform> scaleTransform = vtkSmartPointer<vtkTransform>::New();
   scaleTransform->Scale(ScaleFactor, ScaleFactor, ScaleFactor);
 
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputConnection(appendFilter->GetOutputPort());
   transformFilter->SetTransform(scaleTransform);
 
   transformFilter->Update();
 
   vtkSmartPointer<vtkPolyData> snapshot = vtkSmartPointer<vtkPolyData>::New();
   snapshot->ShallowCopy(transformFilter->GetOutputDataObject(0));
 
   return snapshot;
 }
 
 double mitk::Simulation::GetDefaultDT() const
 {
   return m_DefaultDT;
 }
 
 mitk::SimulationDrawTool* mitk::Simulation::GetDrawTool()
 {
   return &m_DrawTool;
 }
 
 sofa::simulation::Node::SPtr mitk::Simulation::GetRootNode() const
 {
   return m_RootNode;
 }
 
 sofa::simulation::Simulation::SPtr mitk::Simulation::GetSimulation() const
 {
   return m_Simulation;
 }
 
 bool mitk::Simulation::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 void mitk::Simulation::SetAsActiveSimulation()
 {
   SetActiveSimulation(this);
 }
 
 void mitk::Simulation::SetDefaultDT(double dt)
 {
   m_DefaultDT = std::max(0.0, dt);
 }
 
 void mitk::Simulation::SetRequestedRegion(const itk::DataObject*)
 {
 }
 
 void mitk::Simulation::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 void mitk::Simulation::SetRootNode(sofa::simulation::Node* rootNode)
 {
   m_RootNode.reset(rootNode);
 }
 
 mitk::Surface::Pointer mitk::Simulation::TakeSnapshot() const
 {
   vtkSmartPointer<vtkPolyData> snapshot = this->CreateSnapshot();
 
   if (snapshot == NULL)
     return NULL;
 
   Surface::Pointer surface = Surface::New();
   surface->SetVtkPolyData(snapshot);
 
   return surface;
 }
 
 void mitk::Simulation::UpdateOutputInformation()
 {
   if (this->GetSource().IsNotNull())
     this->GetSource()->UpdateOutputInformation();
 
   if (m_RootNode != NULL)
   {
     const sofa::defaulttype::BoundingBox& boundingBox = m_RootNode->f_bbox.getValue();
     const sofa::defaulttype::Vector3& min = boundingBox.minBBox();
     const sofa::defaulttype::Vector3& max = boundingBox.maxBBox();
 
     mitk::Geometry3D::BoundsArrayType bounds;
 
     bounds[0] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.x() * ScaleFactor);
     bounds[1] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.x() * ScaleFactor);
     bounds[2] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.y() * ScaleFactor);
     bounds[3] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.y() * ScaleFactor);
     bounds[4] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.z() * ScaleFactor);
     bounds[5] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.z() * ScaleFactor);
 
     if(this->GetGeometry() != NULL)
     {
       this->GetGeometry()->SetBounds(bounds);
     }
     else
     {
       Geometry3D::Pointer geometry = Geometry3D::New();
       geometry->SetBounds(bounds);
       this->SetGeometry(geometry);
     }
   }
 
-  this->GetTimeSlicedGeometry()->UpdateInformation();
+  this->GetTimeGeometry()->Update();
 }
 
 bool mitk::Simulation::VerifyRequestedRegion()
 {
   return true;
 }
diff --git a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
index dfd90946cb..42f315fd0b 100644
--- a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
@@ -1,398 +1,398 @@
 /*===================================================================
 
 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 <mitkToFCompositeFilter.h>
 #include <mitkInstantiateAccessFunctions.h>
 #include "mitkImageReadAccessor.h"
 
 #include <itkImage.h>
 
 mitk::ToFCompositeFilter::ToFCompositeFilter() : m_SegmentationMask(NULL), m_ImageWidth(0), m_ImageHeight(0), m_ImageSize(0),
 m_IplDistanceImage(NULL), m_IplOutputImage(NULL), m_ItkInputImage(NULL), m_ApplyTemporalMedianFilter(false), m_ApplyAverageFilter(false),
   m_ApplyMedianFilter(false), m_ApplyThresholdFilter(false), m_ApplyMaskSegmentation(false), m_ApplyBilateralFilter(false), m_DataBuffer(NULL),
 m_DataBufferCurrentIndex(0), m_DataBufferMaxSize(0), m_TemporalMedianFilterNumOfFrames(10), m_ThresholdFilterMin(1),
 m_ThresholdFilterMax(7000), m_BilateralFilterDomainSigma(2), m_BilateralFilterRangeSigma(60), m_BilateralFilterKernelRadius(0)
 {
 }
 
 mitk::ToFCompositeFilter::~ToFCompositeFilter()
 {
   cvReleaseImage(&(this->m_IplDistanceImage));
   cvReleaseImage(&(this->m_IplOutputImage));
   if (m_DataBuffer!=NULL)
   {
     delete [] m_DataBuffer;
   }
 }
 
 void mitk::ToFCompositeFilter::SetInput(  mitk::Image* distanceImage )
 {
   this->SetInput(0, distanceImage);
 }
 
 void mitk::ToFCompositeFilter::SetInput( unsigned int idx,  mitk::Image* distanceImage )
 {
   if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
   {
     this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
   }
   else
   {
     if (idx==0) //create IPL image holding distance data
     {
       if (!distanceImage->IsEmpty())
       {
         this->m_ImageWidth = distanceImage->GetDimension(0);
         this->m_ImageHeight = distanceImage->GetDimension(1);
         this->m_ImageSize = this->m_ImageWidth * this->m_ImageHeight * sizeof(float);
 
         if (this->m_IplDistanceImage != NULL)
         {
           cvReleaseImage(&(this->m_IplDistanceImage));
         }
         ImageReadAccessor distImgAcc(distanceImage, distanceImage->GetSliceData(0,0,0));
         float* distanceFloatData = (float*) distImgAcc.GetData();
         this->m_IplDistanceImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
         memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
 
         if (this->m_IplOutputImage != NULL)
         {
           cvReleaseImage(&(this->m_IplOutputImage));
         }
         this->m_IplOutputImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
 
         CreateItkImage(this->m_ItkInputImage);
       }
     }
     this->ProcessObject::SetNthInput(idx, distanceImage);   // Process object is not const-correct so the const_cast is required here
   }
 
   this->CreateOutputsForAllInputs();
 }
 
  mitk::Image* mitk::ToFCompositeFilter::GetInput()
 {
   return this->GetInput(0);
 }
 
  mitk::Image* mitk::ToFCompositeFilter::GetInput( unsigned int idx )
 {
   if (this->GetNumberOfInputs() < 1)
     return NULL; //TODO: geeignete exception werfen
   return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
 }
 
 void mitk::ToFCompositeFilter::GenerateData()
 {
   // copy input 1...n to output 1...n
   for (unsigned int idx=0; idx<this->GetNumberOfOutputs(); idx++)
   {
     mitk::Image::Pointer outputImage = this->GetOutput(idx);
     mitk::Image::Pointer inputImage = this->GetInput(idx);
     if (outputImage.IsNotNull()&&inputImage.IsNotNull())
     {
       ImageReadAccessor inputAcc(inputImage, inputImage->GetSliceData());
       outputImage->CopyInformation(inputImage);
       outputImage->Initialize(inputImage->GetPixelType(),inputImage->GetDimension(),inputImage->GetDimensions());
       outputImage->SetSlice(inputAcc.GetData());
     }
   }
   //mitk::Image::Pointer outputDistanceImage = this->GetOutput();
   ImageReadAccessor outputAcc(this->GetOutput(), this->GetOutput()->GetSliceData(0, 0, 0) );
   float* outputDistanceFloatData = (float*) outputAcc.GetData();
 
   //mitk::Image::Pointer inputDistanceImage = this->GetInput();
   ImageReadAccessor inputAcc(this->GetInput(), this->GetInput()->GetSliceData(0, 0, 0) );
 
   // copy initial distance image to ipl image
   float* distanceFloatData = (float*)inputAcc.GetData();
   memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
   if (m_ApplyThresholdFilter||m_ApplyMaskSegmentation)
   {
     ProcessSegmentation(this->m_IplDistanceImage);
   }
   if (this->m_ApplyTemporalMedianFilter||this->m_ApplyAverageFilter)
   {
     ProcessStreamedQuickSelectMedianImageFilter(this->m_IplDistanceImage);
   }
   if (this->m_ApplyMedianFilter)
   {
     ProcessCVMedianFilter(this->m_IplDistanceImage, this->m_IplOutputImage);
     memcpy( this->m_IplDistanceImage->imageData, this->m_IplOutputImage->imageData, this->m_ImageSize );
   }
   if (this->m_ApplyBilateralFilter)
   {
       float* itkFloatData = this->m_ItkInputImage->GetBufferPointer();
       memcpy(itkFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
       ItkImageType2D::Pointer itkOutputImage = ProcessItkBilateralFilter(this->m_ItkInputImage);
       memcpy( this->m_IplDistanceImage->imageData, itkOutputImage->GetBufferPointer(), this->m_ImageSize );
 
     //ProcessCVBilateralFilter(this->m_IplDistanceImage, this->m_OutputIplImage, domainSigma, rangeSigma, kernelRadius);
     //memcpy( distanceFloatData, this->m_OutputIplImage->imageData, distanceImageSize );
   }
   memcpy( outputDistanceFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
 }
 
 void mitk::ToFCompositeFilter::CreateOutputsForAllInputs()
 {
   this->SetNumberOfOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
   for (unsigned int idx = 0; idx < this->GetNumberOfIndexedInputs(); ++idx)
     if (this->GetOutput(idx) == NULL)
     {
       DataObjectPointer newOutput = this->MakeOutput(idx);
       this->SetNthOutput(idx, newOutput);
     }
     this->Modified();
 }
 
 void mitk::ToFCompositeFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if (output->IsInitialized())
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
-  output->Initialize(input->GetPixelType(), *input->GetTimeSlicedGeometry());
+  output->Initialize(input->GetPixelType(), *input->GetTimeGeometry());
   output->SetPropertyList(input->GetPropertyList()->Clone());
 }
 
 void mitk::ToFCompositeFilter::ProcessSegmentation(IplImage* inputIplImage)
 {
   char* segmentationMask;
   if (m_SegmentationMask.IsNotNull())
   {
     ImageReadAccessor segMaskAcc(m_SegmentationMask, m_SegmentationMask->GetSliceData(0,0,0));
     segmentationMask = (char*)segMaskAcc.GetData();
   }
   else
   {
     segmentationMask = NULL;
   }
   float *f = (float*)inputIplImage->imageData;
   for(int i=0; i<this->m_ImageWidth*this->m_ImageHeight; i++)
   {
     if (this->m_ApplyThresholdFilter)
     {
       if (f[i]<=m_ThresholdFilterMin)
       {
         f[i] = 0.0;
       }
       else if (f[i]>=m_ThresholdFilterMax)
       {
         f[i] = 0.0;
       }
     }
     if (this->m_ApplyMaskSegmentation)
     {
       if (segmentationMask)
       {
         if (segmentationMask[i]==0)
         {
           f[i] = 0.0;
         }
       }
     }
   }
 }
 
 ItkImageType2D::Pointer mitk::ToFCompositeFilter::ProcessItkBilateralFilter(ItkImageType2D::Pointer inputItkImage)
 {
   ItkImageType2D::Pointer outputItkImage;
   BilateralFilterType::Pointer bilateralFilter = BilateralFilterType::New();
   bilateralFilter->SetInput(inputItkImage);
   bilateralFilter->SetDomainSigma(m_BilateralFilterDomainSigma);
   bilateralFilter->SetRangeSigma(m_BilateralFilterRangeSigma);
   //bilateralFilter->SetRadius(m_BilateralFilterKernelRadius);
   outputItkImage = bilateralFilter->GetOutput();
   outputItkImage->Update();
   return outputItkImage;
 }
 
 void mitk::ToFCompositeFilter::ProcessCVBilateralFilter(IplImage* inputIplImage, IplImage* outputIplImage)
 {
   int diameter = m_BilateralFilterKernelRadius;
   double sigmaColor = m_BilateralFilterRangeSigma;
   double sigmaSpace = m_BilateralFilterDomainSigma;
   cvSmooth(inputIplImage, outputIplImage, CV_BILATERAL, diameter, 0, sigmaColor, sigmaSpace);
 }
 
 void mitk::ToFCompositeFilter::ProcessCVMedianFilter(IplImage* inputIplImage, IplImage* outputIplImage, int radius)
 {
   cvSmooth(inputIplImage, outputIplImage, CV_MEDIAN, radius, 0, 0, 0);
 }
 
 void mitk::ToFCompositeFilter::ProcessStreamedQuickSelectMedianImageFilter(IplImage* inputIplImage)
 {
   float* data = (float*)inputIplImage->imageData;
 
   int imageSize = inputIplImage->width * inputIplImage->height;
   float* tmpArray;
 
   if (this->m_TemporalMedianFilterNumOfFrames == 0)
   {
     return;
   }
 
   if (m_TemporalMedianFilterNumOfFrames != this->m_DataBufferMaxSize) // reset
   {
     //delete current buffer
     for( int i=0; i<this->m_DataBufferMaxSize; i++ ) {
       delete[] this->m_DataBuffer[i];
     }
     if (this->m_DataBuffer != NULL)
     {
       delete[] this->m_DataBuffer;
     }
 
     this->m_DataBufferMaxSize = m_TemporalMedianFilterNumOfFrames;
 
     // create new buffer with current size
     this->m_DataBuffer = new float*[this->m_DataBufferMaxSize];
     for(int i=0; i<this->m_DataBufferMaxSize; i++)
     {
       this->m_DataBuffer[i] = NULL;
     }
     this->m_DataBufferCurrentIndex = 0;
   }
 
   int currentBufferSize = this->m_DataBufferMaxSize;
   tmpArray = new float[this->m_DataBufferMaxSize];
 
   // copy data to buffer
   if (this->m_DataBuffer[this->m_DataBufferCurrentIndex] == NULL)
   {
     this->m_DataBuffer[this->m_DataBufferCurrentIndex] = new float[imageSize];
     currentBufferSize = this->m_DataBufferCurrentIndex + 1;
   }
 
   for(int j=0; j<imageSize; j++)
   {
     this->m_DataBuffer[this->m_DataBufferCurrentIndex][j] = data[j];
   }
 
   float tmpValue = 0.0f;
   for(int i=0; i<imageSize; i++)
   {
     if (m_ApplyAverageFilter)
     {
       tmpValue = 0.0f;
       for(int j=0; j<currentBufferSize; j++)
       {
           tmpValue+=this->m_DataBuffer[j][i];
       }
       data[i] = tmpValue/currentBufferSize;
     }
     else if (m_ApplyTemporalMedianFilter)
     {
       for(int j=0; j<currentBufferSize; j++)
       {
         tmpArray[j] = this->m_DataBuffer[j][i];
       }
       data[i] = quick_select(tmpArray, currentBufferSize);
     }
   }
 
   this->m_DataBufferCurrentIndex = (this->m_DataBufferCurrentIndex + 1) % this->m_DataBufferMaxSize;
 
   delete[] tmpArray;
 }
 
 #define ELEM_SWAP(a,b) { register float t=(a);(a)=(b);(b)=t; }
 float mitk::ToFCompositeFilter::quick_select(float arr[], int n)
 {
   int low = 0;
   int high = n-1;
   int median = (low + high)/2;
   int middle = 0;
   int ll = 0;
   int hh = 0;
   for (;;) {
     if (high <= low) /* One element only */
       return arr[median] ;
     if (high == low + 1) { /* Two elements only */
       if (arr[low] > arr[high])
         ELEM_SWAP(arr[low], arr[high]) ;
       return arr[median] ;
     }
     /* Find median of low, middle and high items; swap into position low */
     middle = (low + high) / 2;
     if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ;
     if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ;
     if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ;
     /* Swap low item (now in position middle) into position (low+1) */
     ELEM_SWAP(arr[middle], arr[low+1]) ;
     /* Nibble from each end towards middle, swapping items when stuck */
     ll = low + 1;
     hh = high;
     for (;;) {
       do ll++; while (arr[low] > arr[ll]) ;
       do hh--; while (arr[hh] > arr[low]) ;
       if (hh < ll)
         break;
       ELEM_SWAP(arr[ll], arr[hh]) ;
     }
     /* Swap middle item (in position low) back into correct position */
     ELEM_SWAP(arr[low], arr[hh]) ;
     /* Re-set active partition */
     if (hh <= median)
       low = ll;
     if (hh >= median)
       high = hh - 1;
   }
 }
 #undef ELEM_SWAP
 
 void mitk::ToFCompositeFilter::SetTemporalMedianFilterParameter(int tmporalMedianFilterNumOfFrames)
 {
   this->m_TemporalMedianFilterNumOfFrames = tmporalMedianFilterNumOfFrames;
 }
 
 void mitk::ToFCompositeFilter::SetThresholdFilterParameter(int min, int max)
 {
   if (min > max)
   {
     min = max;
   }
   this->m_ThresholdFilterMin = min;
   this->m_ThresholdFilterMax = max;
 }
 
 void mitk::ToFCompositeFilter::SetBilateralFilterParameter(double domainSigma, double rangeSigma, int kernelRadius = 0)
 {
   this->m_BilateralFilterDomainSigma = domainSigma;
   this->m_BilateralFilterRangeSigma = rangeSigma;
   this->m_BilateralFilterKernelRadius = kernelRadius;
 }
 
 void mitk::ToFCompositeFilter::CreateItkImage(ItkImageType2D::Pointer &itkInputImage)
 {
   itkInputImage = ItkImageType2D::New();
   ItkImageType2D::IndexType startIndex;
   startIndex[0] =   0;  // first index on X
   startIndex[1] =   0;  // first index on Y
   ItkImageType2D::SizeType  size;
   size[0]  = this->m_ImageWidth;  // size along X
   size[1]  = this->m_ImageHeight;  // size along Y
   ItkImageType2D::RegionType region;
   region.SetSize( size );
   region.SetIndex( startIndex );
   itkInputImage->SetRegions( region );
   itkInputImage->Allocate();
 
 }
diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.cpp b/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.cpp
index 4ffcdd94d2..dfe5ff23b7 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.cpp
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.cpp
@@ -1,189 +1,196 @@
 /*===================================================================
 
 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 "mitkIRenderingManager.h"
 
 namespace mitk {
 
 struct RenderingManagerInterface : public IRenderingManager
 {
   RenderingManagerInterface(RenderingManager::Pointer manager)
     : m_RM(manager)
   {}
 
   QList<vtkRenderWindow*> GetAllRegisteredVtkRenderWindows() const
   {
     RenderingManager::RenderWindowVector vec(m_RM->GetAllRegisteredRenderWindows());
     QList<vtkRenderWindow*> result;
     for (RenderingManager::RenderWindowVector::iterator i = vec.begin();
          i != vec.end(); ++i)
     {
       result.append(*i);
     }
     return result;
   }
 
   void RequestUpdate( vtkRenderWindow *renderWindow )
   {
     m_RM->RequestUpdate(renderWindow);
   }
 
   void ForceImmediateUpdate( vtkRenderWindow *renderWindow )
   {
     m_RM->ForceImmediateUpdate(renderWindow);
   }
 
   void RequestUpdateAll( RenderingManager::RequestType type )
   {
     m_RM->RequestUpdateAll(type);
   }
 
   void ForceImmediateUpdateAll( RenderingManager::RequestType type )
   {
     m_RM->ForceImmediateUpdateAll(type);
   }
 
   bool InitializeViews( const Geometry3D *geometry,
                         RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL,
                         bool preserveRoughOrientationInWorldSpace = false )
   {
     return m_RM->InitializeViews( geometry, type, preserveRoughOrientationInWorldSpace);
   }
 
+  bool InitializeViews( const TimeGeometry *geometry,
+                        RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL,
+                        bool preserveRoughOrientationInWorldSpace = false )
+  {
+    return m_RM->InitializeViews( geometry, type, preserveRoughOrientationInWorldSpace);
+  }
+
   bool InitializeViews( RenderingManager::RequestType type )
   {
     return m_RM->InitializeViews(type);
   }
 
   bool InitializeView( vtkRenderWindow *renderWindow, const Geometry3D *geometry,
                                bool initializeGlobalTimeSNC = false)
   {
     return m_RM->InitializeView(renderWindow, geometry, initializeGlobalTimeSNC);
   }
 
   bool InitializeView( vtkRenderWindow *renderWindow )
   {
     return m_RM->InitializeView(renderWindow);
   }
 
   const SliceNavigationController *GetTimeNavigationController() const
   {
     return m_RM->GetTimeNavigationController();
   }
 
   SliceNavigationController *GetTimeNavigationController()
   {
     return m_RM->GetTimeNavigationController();
   }
 
   bool IsRendering() const
   {
     return m_RM->IsRendering();
   }
 
   void AbortRendering()
   {
     m_RM->AbortRendering();
   }
 
   void SetLODIncreaseBlocked(bool blocked)
   {
     m_RM->SetLODIncreaseBlocked(blocked);
   }
 
   bool GetLODIncreaseBlocked() const
   {
     return m_RM->GetLODIncreaseBlocked();
   }
 
   void SetLODAbortMechanismEnabled(bool abort)
   {
     m_RM->SetLODAbortMechanismEnabled(abort);
   }
 
   bool GetLODAbortMechanismEnabled() const
   {
     return m_RM->GetLODAbortMechanismEnabled();
   }
 
   void SetDepthPeelingEnabled(bool enabled)
   {
     m_RM->SetDepthPeelingEnabled(enabled);
   }
 
   void SetMaxNumberOfPeels(int maxNumber)
   {
     m_RM->SetMaxNumberOfPeels(maxNumber);
   }
 
   int GetNextLOD( BaseRenderer* renderer ) const
   {
     return m_RM->GetNextLOD(renderer);
   }
 
   void SetMaximumLOD( unsigned int max )
   {
     m_RM->SetMaximumLOD(max);
   }
 
   void SetShading( bool state, unsigned int lod )
   {
     m_RM->SetShading(state, lod);
   }
 
   bool GetShading( unsigned int lod )
   {
     return m_RM->GetShading(lod);
   }
 
   void SetClippingPlaneStatus( bool status )
   {
     m_RM->SetClippingPlaneStatus(status);
   }
 
   bool GetClippingPlaneStatus()
   {
     return m_RM->GetClippingPlaneStatus();
   }
 
   void SetShadingValues( float ambient, float diffuse,
                          float specular, float specpower )
   {
     m_RM->SetShadingValues(ambient, diffuse, specular, specpower);
   }
 
   QList<float> GetShadingValues() const
   {
     RenderingManager::FloatVector vec(m_RM->GetShadingValues());
     QList<float> result;
     for (RenderingManager::FloatVector::iterator i = vec.begin();
          i != vec.end(); ++i)
     {
       result.push_back(*i);
     }
     return result;
   }
 
   const RenderingManager::Pointer m_RM;
 
 };
 
 IRenderingManager* MakeRenderingManagerInterface(RenderingManager::Pointer manager)
 {
   return new RenderingManagerInterface(manager);
 }
 
 }
diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h b/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h
index 9672fb0a43..5466955b11 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h
@@ -1,158 +1,162 @@
 /*===================================================================
 
 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 MITKIRENDERINGMANAGER_H
 #define MITKIRENDERINGMANAGER_H
 
 #include <mitkRenderingManager.h>
 
 #include <org_mitk_gui_common_Export.h>
 
 #include <QList>
 #include <QtPlugin>
 
 namespace mitk {
 
 /**
  * \ingroup org_mitk_gui_common
  *
  * \brief An interface for accessing a mitk::RenderingManager instance.
  *
  * This interface acts as a wrapper to a mitk::RenderingManager instance, hiding some
  * methods from the user.
  *
  * \see MakeRenderingManagerInterface
  */
 struct IRenderingManager {
 
   virtual ~IRenderingManager() {}
 
   /** Get a list of all registered RenderWindows */
   virtual QList<vtkRenderWindow*> GetAllRegisteredVtkRenderWindows() const = 0;
 
   /**
    * Requests an update for the specified RenderWindow, to be executed as
    * soon as the main loop is ready for rendering.
    */
   virtual void RequestUpdate( vtkRenderWindow *renderWindow ) = 0;
 
   /** Immediately executes an update of the specified RenderWindow. */
   virtual void ForceImmediateUpdate( vtkRenderWindow *renderWindow ) = 0;
 
   /**
    * Requests all currently registered RenderWindows to be updated.
    * If only 2D or 3D windows should be updated, this can be specified
    * via the parameter requestType.
    */
   virtual void RequestUpdateAll( RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL ) = 0;
 
   /**
    * Immediately executes an update of all registered RenderWindows.
    * If only 2D or 3D windows should be updated, this can be specified
    * via the parameter requestType.
    */
   virtual void ForceImmediateUpdateAll( RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL ) = 0;
 
   /** Initializes the windows specified by requestType to the given geometry. */
   virtual bool InitializeViews( const Geometry3D *geometry,
                                 RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL,
                                 bool preserveRoughOrientationInWorldSpace = false ) = 0;
+  virtual bool InitializeViews( const TimeGeometry *geometry,
+                                RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL,
+                                bool preserveRoughOrientationInWorldSpace = false ) = 0;
+
 
   /**
    * Initializes the windows to the default viewing direction
    * (geomtry information is NOT changed).
    */
   virtual bool InitializeViews( RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL ) = 0;
 
   /**
    * Initializes the specified window to the given geometry. Set
    * "initializeGlobalTimeSNC" to true in order to use this geometry as
-   * global TimeSlicedGeometry.
+   * global TimeGeometry.
    */
   virtual bool InitializeView( vtkRenderWindow *renderWindow, const Geometry3D *geometry,
                                bool initializeGlobalTimeSNC = false) = 0;
 
   /**
    * Initializes the specified window to the default viewing direction
    * (geomtry information is NOT changed).
    */
   virtual bool InitializeView( vtkRenderWindow *renderWindow ) = 0;
 
   /** Gets the SliceNavigationController responsible for time-slicing. */
   virtual const SliceNavigationController *GetTimeNavigationController() const = 0;
 
   /** Gets the SliceNavigationController responsible for time-slicing. */
   virtual SliceNavigationController *GetTimeNavigationController() = 0;
 
   virtual bool IsRendering() const = 0;
 
   virtual void AbortRendering() = 0;
 
   /** En-/Disable LOD increase globally. */
   virtual void SetLODIncreaseBlocked(bool blocked) = 0;
 
   /** Get LOD blocked status. */
   virtual bool GetLODIncreaseBlocked() const = 0;
 
   /** En-/Disable LOD abort mechanism. */
   virtual void SetLODAbortMechanismEnabled(bool abort) = 0;
 
   /** Get LOD abort mechanism status. */
   virtual bool GetLODAbortMechanismEnabled() const = 0;
 
   /** En-/Disable depth peeling for all renderers */
   virtual void SetDepthPeelingEnabled(bool enabled) = 0;
 
   /** Set maximum number of peels for all renderers */
   virtual void SetMaxNumberOfPeels(int maxNumber) = 0;
 
   virtual int GetNextLOD( BaseRenderer* renderer ) const = 0;
 
   /** Set current LOD (NULL means all renderers)*/
   virtual void SetMaximumLOD( unsigned int max ) = 0;
 
   virtual void SetShading( bool state, unsigned int lod ) = 0;
   virtual bool GetShading( unsigned int lod ) = 0;
 
   virtual void SetClippingPlaneStatus( bool status ) = 0;
   virtual bool GetClippingPlaneStatus() = 0;
 
   virtual void SetShadingValues( float ambient, float diffuse,
                                  float specular, float specpower ) = 0;
 
   virtual QList<float> GetShadingValues() const = 0;
 
 };
 
 }
 
 Q_DECLARE_INTERFACE(mitk::IRenderingManager, "org.mitk.ui.IRenderingManager")
 
 namespace mitk {
 
 /**
  * Create a IRenderManager interface for a given RenderingManager. Ownership of the
  * returned pointer is transferred to the caller of this function.
  *
  * \param manager The RenderingManager instance for which to create a interface.
  * \return A pointer to the interface object. The caller is responsible for deleting the pointer.
  */
 MITK_GUI_COMMON_PLUGIN IRenderingManager* MakeRenderingManagerInterface(RenderingManager::Pointer manager);
 
 }
 
 #endif // MITKIRENDERINGMANAGER_H
diff --git a/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp b/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp
index 2ef550c4c0..0492c34d58 100644
--- a/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp
+++ b/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp
@@ -1,348 +1,348 @@
 /*===================================================================
 
 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 "mitkWorkbenchUtil.h"
 
 #include <berryPlatformUI.h>
 #include <berryIEditorRegistry.h>
 #include <berryUIException.h>
 #include <berryIPreferencesService.h>
 
 #include <mitkDataNodeFactory.h>
 #include "mitkIDataStorageService.h"
 #include "mitkDataStorageEditorInput.h"
 #include "mitkRenderingManager.h"
 #include "mitkIRenderWindowPart.h"
 #include "mitkIRenderingManager.h"
 
 #include "mitkProperties.h"
 #include "mitkNodePredicateData.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkIOUtil.h"
 #include "mitkWorkbenchUtil.h"
 
 #include <ctkUtils.h>
 
 #include <QMessageBox>
 #include <QApplication>
 #include <QDateTime>
 
 #include "internal/org_mitk_gui_common_Activator.h"
 
 namespace mitk {
 
 struct WorkbenchUtilPrivate {
 
   /**
    * Get the editor descriptor for a given name using the editorDescriptor
    * passed in as a default as a starting point.
    *
    * @param name
    *            The name of the element to open.
    * @param editorReg
    *            The editor registry to do the lookups from.
    * @param defaultDescriptor
    *            IEditorDescriptor or <code>null</code>
    * @return IEditorDescriptor
    * @throws PartInitException
    *             if no valid editor can be found
    */
   static berry::IEditorDescriptor::Pointer GetEditorDescriptor(const QString& name,
                                                                berry::IEditorRegistry* editorReg,
                                                                berry::IEditorDescriptor::Pointer defaultDescriptor)
   {
 
     if (defaultDescriptor.IsNotNull())
     {
       return defaultDescriptor;
     }
 
     berry::IEditorDescriptor::Pointer editorDesc = defaultDescriptor;
 
     // next check the OS for in-place editor (OLE on Win32)
     if (editorReg->IsSystemInPlaceEditorAvailable(name.toStdString()))
     {
       editorDesc = editorReg->FindEditor(berry::IEditorRegistry::SYSTEM_INPLACE_EDITOR_ID);
     }
 
     // next check with the OS for an external editor
     if (editorDesc.IsNull() && editorReg->IsSystemExternalEditorAvailable(name.toStdString()))
     {
       editorDesc = editorReg->FindEditor(berry::IEditorRegistry::SYSTEM_EXTERNAL_EDITOR_ID);
     }
 
     // if no valid editor found, bail out
     if (editorDesc.IsNull())
     {
       throw berry::PartInitException("No editor found");
     }
 
     return editorDesc;
   }
 };
 // //! [UtilLoadFiles]
 void WorkbenchUtil::LoadFiles(const QStringList &fileNames, berry::IWorkbenchWindow::Pointer window, bool openEditor)
 // //! [UtilLoadFiles]
 {
   if (fileNames.empty())
      return;
 
   mitk::IDataStorageReference::Pointer dataStorageRef;
 
   {
     ctkPluginContext* context = mitk::PluginActivator::GetContext();
     mitk::IDataStorageService* dss = 0;
     ctkServiceReference dsRef = context->getServiceReference<mitk::IDataStorageService>();
     if (dsRef)
     {
       dss = context->getService<mitk::IDataStorageService>(dsRef);
     }
 
     if (!dss)
     {
       QString msg = "IDataStorageService service not available. Unable to open files.";
       MITK_WARN << msg.toStdString();
       QMessageBox::warning(QApplication::activeWindow(), "Unable to open files", msg);
       return;
     }
 
     // Get the active data storage (or the default one, if none is active)
     dataStorageRef = dss->GetDataStorage();
     context->ungetService(dsRef);
   }
 
   mitk::DataStorage::Pointer dataStorage = dataStorageRef->GetDataStorage();
 
   // Do the actual work of loading the data into the data storage
   std::vector<std::string> fileNames2;
 
   // Correct conversion for File names.(BUG 12252)
   fileNames2.resize(fileNames.size());
   for (int i = 0; i< fileNames.size(); i++)
     fileNames2[i] = std::string(QFile::encodeName(fileNames[i]).data());
 
   // Old conversion which returns wrong encoded Non-Latin-Characters.
   //ctk::qListToSTLVector(fileNames, fileNames2);
 
   // Turn off ASSERT
   #if defined(_MSC_VER) && !defined(NDEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
       int lastCrtReportType = _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_DEBUG );
   #endif
 
   const bool dsmodified = mitk::IOUtil::LoadFiles(fileNames2, *dataStorage);
 
   // Set ASSERT status back to previous status.
   #if defined(_MSC_VER) && !defined(NDEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
     if (lastCrtReportType)
       _CrtSetReportMode( _CRT_ASSERT, lastCrtReportType );
   #endif
 
   // Check if there is an open perspective. If not, open the default perspective.
   if (window->GetActivePage().IsNull())
   {
     std::string defaultPerspId = window->GetWorkbench()->GetPerspectiveRegistry()->GetDefaultPerspective();
     window->GetWorkbench()->ShowPerspective(defaultPerspId, window);
   }
 
   if (openEditor)
   {
     try
     {
       // Activate the editor using the same data storage or open the default editor
       mitk::DataStorageEditorInput::Pointer input(new mitk::DataStorageEditorInput(dataStorageRef));
       berry::IEditorPart::Pointer editor = mitk::WorkbenchUtil::OpenEditor(window->GetActivePage(), input, true);
       mitk::IRenderWindowPart* renderEditor = dynamic_cast<mitk::IRenderWindowPart*>(editor.GetPointer());
       mitk::IRenderingManager* renderingManager = renderEditor == 0 ? 0 : renderEditor->GetRenderingManager();
 
       if(dsmodified && renderingManager)
       {
         // get all nodes that have not set "includeInBoundingBox" to false
         mitk::NodePredicateNot::Pointer pred
             = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
                                                                            , mitk::BoolProperty::New(false)));
 
         mitk::DataStorage::SetOfObjects::ConstPointer rs = dataStorage->GetSubset(pred);
         // calculate bounding geometry of these nodes
-        mitk::TimeSlicedGeometry::Pointer bounds = dataStorage->ComputeBoundingGeometry3D(rs);
+        mitk::TimeGeometry::Pointer bounds = dataStorage->ComputeBoundingGeometry3D(rs);
         // initialize the views to the bounding geometry
         renderingManager->InitializeViews(bounds);
       }
     }
     catch (const berry::PartInitException& e)
     {
       QString msg = "An error occurred when displaying the file(s): %1";
       QMessageBox::warning(QApplication::activeWindow(), "Error displaying file",
                            msg.arg(QString::fromStdString(e.message())));
     }
   }
 }
 
 berry::IEditorPart::Pointer WorkbenchUtil::OpenEditor(berry::IWorkbenchPage::Pointer page,
                                                       berry::IEditorInput::Pointer input,
                                                       const QString &editorId, bool activate)
 {
   // sanity checks
   if (page.IsNull())
   {
     throw std::invalid_argument("page argument must not be NULL");
   }
 
   // open the editor on the input
   return page->OpenEditor(input, editorId.toStdString(), activate);
 }
 
 berry::IEditorPart::Pointer WorkbenchUtil::OpenEditor(berry::IWorkbenchPage::Pointer page,
                                                       mitk::DataStorageEditorInput::Pointer input,
                                                       bool activate,
                                                       bool determineContentType)
 {
   // sanity checks
   if (page.IsNull())
   {
     throw std::invalid_argument("page argument must not be NULL");
   }
 
   // open the editor on the data storage
   QString name = QString::fromStdString(input->GetName()) + ".mitk";
   berry::IEditorDescriptor::Pointer editorDesc =
       WorkbenchUtilPrivate::GetEditorDescriptor(name,
                                                 berry::PlatformUI::GetWorkbench()->GetEditorRegistry(),
                                                 GetDefaultEditor(name, determineContentType));
   return page->OpenEditor(input, editorDesc->GetId(), activate);
 }
 
 berry::IEditorDescriptor::Pointer WorkbenchUtil::GetEditorDescriptor(
     const QString& name, bool /*inferContentType*/)
 {
   if (name.isEmpty())
   {
     throw std::invalid_argument("name argument must not be empty");
   }
 
   // no used for now
   //IContentType contentType = inferContentType ? Platform
   //                                              .getContentTypeManager().findContentTypeFor(name) : null;
 
   berry::IEditorRegistry* editorReg = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
 
   return WorkbenchUtilPrivate::GetEditorDescriptor(name, editorReg,
                                                    editorReg->GetDefaultEditor(name.toStdString() /*, contentType*/));
 }
 
 berry::IEditorDescriptor::Pointer WorkbenchUtil::GetDefaultEditor(const QString& name,
                                                                   bool /*determineContentType*/)
 {
   // Try file specific editor.
   berry::IEditorRegistry* editorReg = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
   try
   {
     QString editorID; // = file.getPersistentProperty(EDITOR_KEY);
     if (!editorID.isEmpty())
     {
       berry::IEditorDescriptor::Pointer desc = editorReg->FindEditor(editorID.toStdString());
       if (desc.IsNotNull())
       {
         return desc;
       }
     }
   }
   catch (const berry::CoreException&)
   {
     // do nothing
   }
 
 //  IContentType contentType = null;
 //  if (determineContentType)
 //  {
 //    contentType = getContentType(file);
 //  }
 
   // Try lookup with filename
   return editorReg->GetDefaultEditor(name.toStdString()); //, contentType);
 }
 
 bool WorkbenchUtil::SetDepartmentLogoPreference(const QString &logoResource, ctkPluginContext *context)
 {
   // The logo must be available in the local filesystem. We check if we have not already extracted the
   // logo from the plug-in or if this plug-ins timestamp is newer then the already extracted logo timestamp.
   // If one of the conditions is true, extract it and write it to the plug-in specific storage location.
   const QString logoFileName = logoResource.mid(logoResource.lastIndexOf('/')+1);
   const QString logoPath = context->getDataFile("").absoluteFilePath();
 
   bool extractLogo = true;
   QFileInfo logoFileInfo(logoPath + "/" + logoFileName);
 
   if (logoFileInfo.exists())
   {
     // The logo has been extracted previously. Check if the plugin timestamp is newer, which
     // means it might contain an updated logo.
     QString pluginLocation = QUrl(context->getPlugin()->getLocation()).toLocalFile();
     if (!pluginLocation.isEmpty())
     {
       QFileInfo pluginFileInfo(pluginLocation);
       if (logoFileInfo.lastModified() > pluginFileInfo.lastModified())
       {
         extractLogo = false;
       }
     }
   }
 
   if (extractLogo)
   {
     // Extract the logo from the shared library and write it to disk.
     QFile logo(logoResource);
     if (logo.open(QIODevice::ReadOnly))
     {
       QFile localLogo(logoPath + "/" + logoFileName);
       if (localLogo.open(QIODevice::WriteOnly))
       {
         localLogo.write(logo.readAll());
       }
     }
   }
 
   logoFileInfo.refresh();
   if (logoFileInfo.exists())
   {
     // Get the preferences service
     ctkServiceReference prefServiceRef = context->getServiceReference<berry::IPreferencesService>();
     berry::IPreferencesService* prefService = NULL;
     if (prefServiceRef)
     {
       prefService = context->getService<berry::IPreferencesService>(prefServiceRef);
     }
 
     if (prefService)
     {
       prefService->GetSystemPreferences()->Put("DepartmentLogo", qPrintable(logoFileInfo.absoluteFilePath()));
     }
     else
     {
       BERRY_WARN << "Preferences service not available, unable to set custom logo.";
       return false;
     }
   }
   else
   {
     BERRY_WARN << "Custom logo at " << logoFileInfo.absoluteFilePath().toStdString() << " does not exist";
     return false;
   }
   return true;
 }
 
 } // namespace mitk
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
index 3b54bc56e7..3bc2da8985 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
@@ -1,946 +1,946 @@
 /*===================================================================
 
 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 "mitkPACSPlugin.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkColorProperty.h"
 #include "mitkCommon.h"
 #include "mitkDelegateManager.h"
 #include "mitkNodePredicateData.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkEnumerationProperty.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"
 //## 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"
 
 const std::string QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager";
 
 QmitkDataManagerView::QmitkDataManagerView()
     : m_GlobalReinitOnNodeDelete(true)
 {
 }
 
 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->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));
   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_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 == "QmitkOtsuAction")
   {
     contextMenuAction->SetDataStorage(this->GetDataStorage());
   }
   else 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)
   {
     QColor color = QColorDialog::getColor();
     m_ColorButton->setAutoFillBackground(true);
     node->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0,color.green()/255.0,color.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::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
         {
            mitk::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->GetTimeSlicedGeometry()->IsValid() )
+      basedata->GetTimeGeometry()->IsValid() )
     {
       renderWindow->GetRenderingManager()->InitializeViews(
-            basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+          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*/ )
     {
       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->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+          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;
 
   // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   renderWindow->GetRenderingManager()->InitializeViews(bounds);
 }
 
 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.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp b/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
index 2516a8faae..cc95852578 100644
--- a/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
@@ -1,268 +1,268 @@
 /*===================================================================
 
 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 "QmitkDataManagerLightView.h"
 #include "mitkNodePredicateDataType.h"
 #include <QtGui>
 #include <mitkCoreObjectFactory.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkIRenderingManager.h>
 
 const std::string QmitkDataManagerLightView::VIEW_ID = "org.mitk.views.datamanagerlight";
 
 struct QmitkDataManagerLightViewData
 {
     // static
     mitk::NodePredicateBase::Pointer m_Predicate;
     QIcon m_ItemIcon;
 
     // data
     QList<mitk::DataNode*> m_DataNodes;
     int m_CurrentIndex;
 
     // widget
     QListWidget* m_ListWidget;
     QLabel* m_ImageInfoLabel;
     QPushButton* m_RemoveButton;
 
 };
 
 QmitkDataManagerLightView::QmitkDataManagerLightView()
     : d( new QmitkDataManagerLightViewData )
 {
     d->m_Predicate = mitk::NodePredicateDataType::New("Image");
     d->m_ItemIcon = QIcon(":/org.mitk.gui.qt.datamanagerlight/Image_24.png");
     d->m_CurrentIndex = -1;
     d->m_ListWidget = 0;
     d->m_ImageInfoLabel = 0;
     d->m_RemoveButton = 0;
 }
 
 QmitkDataManagerLightView::~QmitkDataManagerLightView()
 {
     delete d;
 }
 
 void QmitkDataManagerLightView::NodeAdded(const mitk::DataNode *node)
 {
     if( d->m_Predicate->CheckNode(node) )
     {
         mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
         d->m_DataNodes.append(nonConstNode);
         d->m_ListWidget->addItem( new QListWidgetItem( d->m_ItemIcon, QString::fromStdString( node->GetName() ) ) );
     }
 }
 
 void QmitkDataManagerLightView::NodeRemoved(const mitk::DataNode *node)
 {
     this->RemoveNode( const_cast<mitk::DataNode*>(node) );
 }
 
 void QmitkDataManagerLightView::NodeChanged(const mitk::DataNode *node)
 {
     MITK_DEBUG << "NodeChanged";
     if( d->m_DataNodes.contains(const_cast<mitk::DataNode*>(node)) )
         this->ToggleVisibility();
 }
 
 void QmitkDataManagerLightView::RemoveNode(mitk::DataNode *node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     int index = d->m_DataNodes.indexOf(nonConstNode);
     if( index >= 0 )
     {
         MITK_DEBUG << "removing node at: " << index;
         QListWidgetItem* item = d->m_ListWidget->takeItem(index);
         delete item;
 
         d->m_DataNodes.removeAt(index);
         MITK_DEBUG << "item deleted";
     }
 }
 
 void QmitkDataManagerLightView::CreateQtPartControl(QWidget* parent)
 {
 
     QPushButton* loadButton = new QPushButton(QIcon(":/org.mitk.gui.qt.datamanagerlight/Load_48.png"), "Load");
     d->m_RemoveButton = new QPushButton(QIcon(":/org.mitk.gui.qt.datamanagerlight/Remove_48.png"), "Remove");
     d->m_RemoveButton->setEnabled(false);
 
     d->m_ListWidget = new QListWidget;
 
     d->m_ImageInfoLabel = new QLabel;
 
     QGridLayout* layout = new QGridLayout;
     layout->addWidget( loadButton, 0,0 );
     layout->addWidget( d->m_RemoveButton, 0,1 );
     layout->addWidget( d->m_ImageInfoLabel, 1,0, 1, 2 );
     layout->addWidget( d->m_ListWidget, 2,0,1,2 );
 
     parent->setLayout(layout);
 
     connect(d->m_ListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(on_DataItemList_currentRowChanged(int)) );
     connect(loadButton, SIGNAL(pressed()), this, SLOT(on_Load_pressed()) );
     connect(d->m_RemoveButton, SIGNAL(pressed()), this, SLOT(on_Remove_pressed()) );
 
     this->ListSelectionChanged();
 }
 
 void QmitkDataManagerLightView::SetFocus()
 {
     d->m_ListWidget->setFocus();
 }
 
 void QmitkDataManagerLightView::on_DataItemList_currentRowChanged(int currentRow)
 {
     MITK_DEBUG << "DataItemList currentRowChanged: " << currentRow;
     Q_UNUSED(currentRow)
 
     this->ListSelectionChanged();
 }
 
 void QmitkDataManagerLightView::ListSelectionChanged()
 {
     d->m_CurrentIndex = d->m_ListWidget->currentRow();
     MITK_DEBUG << "the currently selected index: " << d->m_CurrentIndex;
 
     QString newLabelText = "Current patient: ";
     if( d->m_CurrentIndex >= 0 )
     {
         // TODO WHERE IS THE PATIENT NAME?
         std::string name = d->m_DataNodes.at(d->m_CurrentIndex)->GetName();
         newLabelText.append( QString("<strong>%1</strong>" ).arg( QString::fromStdString(name) ) );
         d->m_RemoveButton->setEnabled(true);
     }
     else
     {
         newLabelText.append("<strong>Unknown</strong>");
         d->m_RemoveButton->setEnabled(false);
     }
     d->m_ImageInfoLabel->setText(newLabelText);
     this->ToggleVisibility();
 }
 
 void QmitkDataManagerLightView::on_Load_pressed()
 {
     MITK_DEBUG << "on_Load_pressed";
   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 QmitkDataManagerLightView::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->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+          basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
   }
   catch ( itk::ExceptionObject & ex )
   {
     MITK_ERROR << "Exception during file open: " << ex;
   }
 
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkDataManagerLightView::on_Remove_pressed()
 {
     d->m_CurrentIndex = d->m_ListWidget->currentRow();
     MITK_DEBUG << "the currently selected index: " << d->m_CurrentIndex;
 
     mitk::DataNode* node = d->m_DataNodes.at(d->m_CurrentIndex);
     QString question = tr("Do you really want to remove ");
     // TODO patient name?
     question.append( QString::fromStdString( node->GetName() ) );
     question.append(" ?");
 
     QMessageBox::StandardButton answerButton = QMessageBox::question( NULL
       , tr("DataManagerLight")
       , question
       , QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
     if(answerButton == QMessageBox::Yes)
     {
         this->GetDataStorage()->Remove(node);
         this->GlobalReinit();
     }
 }
 
 void QmitkDataManagerLightView::GlobalReinit()
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   // no render window available
   if (renderWindow == NULL) return;
 
   // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   renderWindow->GetRenderingManager()->InitializeViews(bounds);
 }
 
 void QmitkDataManagerLightView::ToggleVisibility()
 {
     bool changedAnything = false;
     bool isVisible = false;
     for(size_t i=0; i<d->m_DataNodes.size(); ++i)
     {
         isVisible = false;
         d->m_DataNodes.at(i)->GetVisibility(isVisible, 0 );
 
         if( d->m_CurrentIndex == i && isVisible == false )
         {
             d->m_DataNodes.at(i)->SetVisibility(true);
             changedAnything = true;
         }
         else if( d->m_CurrentIndex != i && isVisible == true )
         {
             d->m_DataNodes.at(i)->SetVisibility(false);
             changedAnything = true;
         }
     }
 
     if( changedAnything )
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
index ccee2f9b5d..0bc0ef41e2 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
@@ -1,99 +1,99 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 #include "DicomEventHandler.h"
 #include <service/event/ctkEventConstants.h>
 #include <ctkDictionary.h>
 #include <mitkLogMacros.h>
 #include <mitkDicomSeriesReader.h>
 #include <mitkDataNode.h>
 #include <QmitkBaseFunctionalityComponent.h>
 #include <mitkIDataStorageService.h>
 #include <service/event/ctkEventAdmin.h>
 #include <ctkServiceReference.h>
 #include <mitkRenderingManager.h>
 #include <QVector>
 
 
 DicomEventHandler::DicomEventHandler()
 {
 }
 
 DicomEventHandler::~DicomEventHandler()
 {
 }
 
 void DicomEventHandler::OnSignalAddSeriesToDataManager(const ctkEvent& ctkEvent)
 {
     QStringList listOfFilesForSeries;
     mitk::DicomSeriesReader::StringContainer seriesToLoad;
 
     listOfFilesForSeries = ctkEvent.getProperty("FilesForSeries").toStringList();
 
     if (!listOfFilesForSeries.isEmpty()){
 
         QStringListIterator it(listOfFilesForSeries);
 
         while (it.hasNext())
         {
             seriesToLoad.push_back(it.next().toStdString());
         }
 
 
         mitk::DataNode::Pointer node = mitk::DicomSeriesReader::LoadDicomSeries(seriesToLoad);
         if (node.IsNull())
         {
             MITK_ERROR << "Error loading series: " << ctkEvent.getProperty("SeriesName").toString().toStdString()
                 << " id: " <<ctkEvent.getProperty("SeriesUID").toString().toStdString();
         }
         else
         {
             //Get Reference for default data storage.
             ctkServiceReference serviceReference =mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
             mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
             mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
             dataStorage->Add(node);
 
             // Initialize the RenderWindow
-            mitk::TimeSlicedGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
+            mitk::TimeGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
             mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
         }
     }
     else
     {
         MITK_INFO << "There are no files for the current series";
     }
 }
 
 void DicomEventHandler::OnSignalRemoveSeriesFromStorage(const ctkEvent& ctkEvent)
 {
 }
 
 void DicomEventHandler::SubscribeSlots()
 {
     ctkServiceReference ref = mitk::PluginActivator::getContext()->getServiceReference<ctkEventAdmin>();
     if (ref)
     {
         ctkEventAdmin* eventAdmin = mitk::PluginActivator::getContext()->getService<ctkEventAdmin>(ref);
         ctkDictionary properties;
         properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/ADD";
         eventAdmin->subscribeSlot(this, SLOT(OnSignalAddSeriesToDataManager(ctkEvent)), properties);
         properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/DELETED";
         eventAdmin->subscribeSlot(this, SLOT(OnSignalRemoveSeriesFromStorage(ctkEvent)), properties);
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index 4409694e8f..92d153b6aa 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1846 +1,1846 @@
 /*===================================================================
 
 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 "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkTbssImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundleX.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
 #include <mitkDiffusionImage.h>
 #include <mitkConnectomicsNetwork.h>
 #include "mitkGlobalInteraction.h"
 #include "usModuleRegistry.h"
 
 #include "mitkGeometry2D.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include <itkTractDensityImageFilter.h>
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 #include <itkMultiThreader.h>
 
 #define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 static bool DetermineAffectedImageSlice( const mitk::Image* image, const mitk::PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   mitk::Vector3D normal       = plane->GetNormal();
   mitk::Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   mitk::Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   mitk::Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal0.GetVnlVector()) );
   imageNormal1.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal1.GetVnlVector()) );
   imageNormal2.SetVnlVector( vnl_cross_3d<mitk::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
   mitk::Geometry3D* imageGeometry = image->GetGeometry(0);
   mitk::Point3D testPoint = imageGeometry->GetCenter();
   mitk::Point3D projectedPoint;
   plane->Project( testPoint, projectedPoint );
 
   mitk::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;
 }
 
 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
 
 using namespace berry;
 
 struct CvpSelListener : ISelectionListener
 {
 
   berryObjectMacro(CvpSelListener);
 
   CvpSelListener(QmitkControlVisualizationPropertiesView* view)
   {
     m_View = view;
   }
 
   void ApplySettings(mitk::DataNode::Pointer node)
   {
     bool tex_int;
     node->GetBoolProperty("texture interpolation", tex_int);
     if(tex_int)
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
       m_View->m_Controls->m_TextureIntON->setChecked(true);
       m_View->m_TexIsOn = true;
     }
     else
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
       m_View->m_Controls->m_TextureIntON->setChecked(false);
       m_View->m_TexIsOn = false;
     }
 
     int val;
     node->GetIntProperty("ShowMaxNumber", val);
     m_View->m_Controls->m_ShowMaxNumber->setValue(val);
 
     m_View->m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
 
     float fval;
     node->GetFloatProperty("Scaling",fval);
     m_View->m_Controls->m_ScalingFactor->setValue(fval);
 
     m_View->m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
 
     node->GetFloatProperty("IndexParam1",fval);
     m_View->m_Controls->m_IndexParam1->setValue(fval);
 
     node->GetFloatProperty("IndexParam2",fval);
     m_View->m_Controls->m_IndexParam2->setValue(fval);
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     m_View->m_Controls->m_VisibleOdfsON_T->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_S->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_C->setVisible(false);
     m_View->m_Controls->m_TextureIntON->setVisible(false);
 
     m_View->m_Controls->m_ImageControlsFrame->setVisible(false);
     m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(false);
     m_View->m_Controls->m_BundleControlsFrame->setVisible(false);
     m_View->m_SelectedNode = 0;
 
     if(m_View->m_CurrentSelection.IsNull())
       return;
 
     if(m_View->m_CurrentSelection->Size() == 1)
     {
       mitk::DataNodeObject::Pointer nodeObj = m_View->m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
       if(nodeObj.IsNotNull())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
         // check if node has data,
         // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
         mitk::BaseData* nodeData = node->GetData();
 
         if(nodeData != NULL )
         {
           if(dynamic_cast<mitk::PlanarFigure*>(nodeData) != 0)
           {
             m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(true);
             m_View->m_SelectedNode = node;
 
             float val;
             node->GetFloatProperty("planarfigure.line.width", val);
             m_View->m_Controls->m_PFWidth->setValue((int)(val*10.0));
 
             QString label = "Width %1";
             label = label.arg(val);
             m_View->m_Controls->label_pfwidth->setText(label);
 
             float color[3];
             node->GetColor( color, NULL, "planarfigure.default.line.color");
             QString styleSheet = "background-color:rgb(";
             styleSheet.append(QString::number(color[0]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[1]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[2]*255.0));
             styleSheet.append(")");
             m_View->m_Controls->m_PFColor->setAutoFillBackground(true);
             m_View->m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
             node->GetColor( color, NULL, "color");
             styleSheet = "background-color:rgb(";
             styleSheet.append(QString::number(color[0]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[1]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[2]*255.0));
             styleSheet.append(")");
 
             m_View->PlanarFigureFocus();
           }
 
           if(dynamic_cast<mitk::FiberBundleX*>(nodeData) != 0)
           {
             m_View->m_Controls->m_BundleControlsFrame->setVisible(true);
             m_View->m_SelectedNode = node;
 
             if(m_View->m_CurrentPickingNode != 0 && node.GetPointer() != m_View->m_CurrentPickingNode)
             {
               m_View->m_Controls->m_Crosshair->setEnabled(false);
             }
             else
             {
               m_View->m_Controls->m_Crosshair->setEnabled(true);
             }
 
             float val;
             node->GetFloatProperty("TubeRadius", val);
             m_View->m_Controls->m_TubeRadius->setValue((int)(val * 100.0));
 
             QString label = "Radius %1";
             label = label.arg(val);
             m_View->m_Controls->label_tuberadius->setText(label);
 
             int width;
             node->GetIntProperty("LineWidth", width);
             m_View->m_Controls->m_LineWidth->setValue(width);
 
             label = "Width %1";
             label = label.arg(width);
             m_View->m_Controls->label_linewidth->setText(label);
 
             float range;
             node->GetFloatProperty("Fiber2DSliceThickness",range);
             label = "Range %1";
             label = label.arg(range*0.1);
             m_View->m_Controls->label_range->setText(label);
 
           }
 
         } // check node data != NULL
       }
     }
 
     if(m_View->m_CurrentSelection->Size() > 0 && m_View->m_SelectedNode == 0)
     {
       m_View->m_Controls->m_ImageControlsFrame->setVisible(true);
 
       bool foundDiffusionImage = false;
       bool foundQBIVolume = false;
       bool foundTensorVolume = false;
       bool foundImage = false;
       bool foundMultipleOdfImages = false;
       bool foundRGBAImage = false;
       bool foundTbssImage = false;
 
       // do something with the selected items
       if(m_View->m_CurrentSelection)
       {
         // 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();
 
             mitk::BaseData* nodeData = node->GetData();
 
             if(nodeData != NULL )
             {
               // only look at interesting types
               if(QString("DiffusionImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundDiffusionImage = true;
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
                 int val;
                 node->GetIntProperty("DisplayChannel", val);
                 m_View->m_Controls->m_DisplayIndex->setValue(val);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
 
                 QString label = "Channel %1";
                 label = label.arg(val);
                 m_View->m_Controls->label_channel->setText(label);
 
                 int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(nodeData))->GetVectorImage()->GetVectorLength();
                 m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
               }
 
               if(QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundTbssImage = true;
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
                 int val;
                 node->GetIntProperty("DisplayChannel", val);
                 m_View->m_Controls->m_DisplayIndex->setValue(val);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
 
                 QString label = "Channel %1";
                 label = label.arg(val);
                 m_View->m_Controls->label_channel->setText(label);
 
                 int maxVal = (dynamic_cast<mitk::TbssImage* >(nodeData))->GetImage()->GetVectorLength();
                 m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
               }
 
 
               else if(QString("QBallImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
                 foundQBIVolume = true;
                 ApplySettings(node);
               }
 
               else if(QString("TensorImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
                 foundTensorVolume = true;
                 ApplySettings(node);
               }
 
               else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
               {
                 foundImage = true;
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(nodeData);
                 if(img.IsNotNull()
                   && img->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA
                   && img->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR )
                 {
                   foundRGBAImage = true;
                 }
 
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
               }
 
             } // END CHECK node != NULL
           }
         }
       }
 
       m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
         && !foundMultipleOdfImages;
       m_View->m_Controls->m_NumberGlyphsFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
       m_View->m_Controls->m_NormalizationDropdown->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->label->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_ScalingFactor->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_AdditionalScaling->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_NormalizationScalingFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
       m_View->m_Controls->OpacMinFrame->setVisible(foundRGBAImage || m_View->m_FoundSingleOdfImage);
 
       // changed for SPIE paper, Principle curvature scaling
       //m_View->m_Controls->params_frame->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->params_frame->setVisible(false);
 
       m_View->m_Controls->m_VisibleOdfsON_T->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_VisibleOdfsON_S->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_VisibleOdfsON_C->setVisible(m_View->m_FoundSingleOdfImage);
 
       bool foundAnyImage = foundDiffusionImage ||
         foundQBIVolume || foundTensorVolume || foundImage || foundTbssImage;
 
       m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
       m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
       m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
 
     }
   }
 
   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("Datamanager")==0)
       {
 
         // apply selection
         DoSelectionChanged(selection);
 
       }
     }
   }
 
   QmitkControlVisualizationPropertiesView* m_View;
 };
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
   m_NodeUsedForOdfVisualization(NULL),
   m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
   m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
   m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
   m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
   m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
   m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
   m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
   m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
   m_CurrentSelection(0),
   m_CurrentPickingNode(0),
   m_GlyIsOn_S(false),
   m_GlyIsOn_C(false),
   m_GlyIsOn_T(false),
   m_FiberBundleObserverTag(0),
   m_Color(NULL)
 {
   currentThickSlicesMode = 1;
   m_MyMenu = NULL;
   itk::MultiThreader::SetGlobalDefaultNumberOfThreads(itk::MultiThreader::GetGlobalMaximumNumberOfThreads());
 }
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
 {
   Q_UNUSED(other)
     throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
   if(m_SlicesRotationObserverTag1 )
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if( coordinator)
       coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
   }
   if( m_SlicesRotationObserverTag2)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if( coordinator )
       coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
   }
 
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
 {
   currentThickSlicesMode = action->data().toInt();
 
   switch(currentThickSlicesMode)
   {
   default:
   case 1:
     this->m_Controls->m_TSMenu->setText("MIP");
     break;
   case 2:
     this->m_Controls->m_TSMenu->setText("SUM");
     break;
   case 3:
     this->m_Controls->m_TSMenu->setText("WEIGH");
     break;
   }
 
   mitk::DataNode* n;
   n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 
   mitk::BaseRenderer::Pointer renderer =
     this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer->GetRenderingManager()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::OnTSNumChanged(int num)
 {
   if(num==0)
   {
     mitk::DataNode* n;
     n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
   }
   else
   {
     mitk::DataNode* n;
     n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 
     n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
   }
 
   m_TSLabel->setText(QString::number(num*2+1));
 
   mitk::BaseRenderer::Pointer renderer =
     this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
 }
 
 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     // hide warning (ODFs in rotated planes)
     m_Controls->m_lblRotatedPlanesWarning->hide();
 
     m_MyMenu = new QMenu(parent);
     connect( m_MyMenu, SIGNAL( aboutToShow() ), this, SLOT(OnMenuAboutToShow()) );
 
     // button for changing rotation mode
     m_Controls->m_TSMenu->setMenu( m_MyMenu );
     //m_CrosshairModeButton->setIcon( QIcon( iconCrosshairMode_xpm ) );
 
     m_Controls->params_frame->setVisible(false);
 
     QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
     m_Controls->m_Reinit->setIcon(icon5);
     m_Controls->m_Focus->setIcon(icon5);
 
     QIcon iconColor(":/QmitkDiffusionImaging/color24.gif");
     m_Controls->m_PFColor->setIcon(iconColor);
     m_Controls->m_Color->setIcon(iconColor);
 
     QIcon iconReset(":/QmitkDiffusionImaging/reset.png");
     m_Controls->m_ResetColoring->setIcon(iconReset);
 
     m_Controls->m_PFColor->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
 
     QIcon iconCrosshair(":/QmitkDiffusionImaging/crosshair.png");
     m_Controls->m_Crosshair->setIcon(iconCrosshair);
     // was is los
     QIcon iconPaint(":/QmitkDiffusionImaging/paint2.png");
     m_Controls->m_TDI->setIcon(iconPaint);
 
     QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
     m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
 
     m_Controls->m_TextureIntON->setCheckable(true);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     int size = m_Controls->m_AdditionalScaling->count();
     for(int t=0; t<size; t++)
     {
       if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
       {
         m_Controls->m_AdditionalScaling->removeItem(t);
       }
     }
 #endif
 
     m_Controls->m_OpacitySlider->setRange(0.0,1.0);
     m_Controls->m_OpacitySlider->setLowerValue(0.0);
     m_Controls->m_OpacitySlider->setUpperValue(0.0);
 
     m_Controls->m_ScalingFrame->setVisible(false);
     m_Controls->m_NormalizationFrame->setVisible(false);
     m_Controls->frame_tube->setVisible(false);
     m_Controls->frame_wire->setVisible(false);
   }
 
 
 
   m_IsInitialized = false;
   m_SelListener = berry::ISelectionListener::Pointer(new CvpSelListener(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<CvpSelListener>()->DoSelectionChanged(sel);
   m_IsInitialized = true;
 }
 
 void QmitkControlVisualizationPropertiesView::OnMenuAboutToShow ()
 {
   // THICK SLICE SUPPORT
   QMenu *myMenu = m_MyMenu;
   myMenu->clear();
 
   QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
   thickSlicesActionGroup->setExclusive(true);
 
   mitk::BaseRenderer::Pointer renderer =
     this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
 
   int currentTSMode = 0;
   {
     mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices" ));
     if( m.IsNotNull() )
       currentTSMode = m->GetValueAsId();
   }
 
   const int maxTS = 30;
 
   int currentNum = 0;
   {
     mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices.num" ));
     if( m.IsNotNull() )
     {
       currentNum = m->GetValue();
       if(currentNum < 0) currentNum = 0;
       if(currentNum > maxTS) currentNum = maxTS;
     }
   }
 
   if(currentTSMode==0)
     currentNum=0;
 
   QSlider *m_TSSlider = new QSlider(myMenu);
   m_TSSlider->setMinimum(0);
   m_TSSlider->setMaximum(maxTS-1);
   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(m_TSSlider);
   _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
 
   QWidget* _TSWidget = new QWidget;
   _TSWidget->setLayout(_TSLayout);
 
   QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
   thickSliceModeActionGroup->setExclusive(true);
 
   QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
   m_TSSliderAction->setDefaultWidget(_TSWidget);
   myMenu->addAction(m_TSSliderAction);
 
   QAction* mipThickSlicesAction = new QAction(myMenu);
   mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   mipThickSlicesAction->setText("MIP (max. intensity proj.)");
   mipThickSlicesAction->setCheckable(true);
   mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
   mipThickSlicesAction->setData(1);
   myMenu->addAction( mipThickSlicesAction );
 
   QAction* sumThickSlicesAction = new QAction(myMenu);
   sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   sumThickSlicesAction->setText("SUM (sum intensity proj.)");
   sumThickSlicesAction->setCheckable(true);
   sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
   sumThickSlicesAction->setData(2);
   myMenu->addAction( sumThickSlicesAction );
 
   QAction* weightedThickSlicesAction = new QAction(myMenu);
   weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
   weightedThickSlicesAction->setCheckable(true);
   weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
   weightedThickSlicesAction->setData(3);
   myMenu->addAction( weightedThickSlicesAction );
 
   connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
 }
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 
   if (m_MultiWidget)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
       m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
 
     coordinator = m_MultiWidget->GetSlicesSwiveller();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
       m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
 {
   // test if plane rotated
   if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
   {
     if( this->IsPlaneRotated() )
     {
       // show label
       m_Controls->m_lblRotatedPlanesWarning->show();
     }
     else
     {
       //hide label
       m_Controls->m_lblRotatedPlanesWarning->hide();
     }
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkControlVisualizationPropertiesView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_DisplayIndex), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
     connect( (QObject*)(m_Controls->m_DisplayIndexSpinBox), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
 
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
     connect( (QObject*)(m_Controls->m_Reinit), SIGNAL(clicked()), this, SLOT(Reinit()) );
 
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
 
     connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
     connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
     connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
     connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
     connect( (QObject*)(m_Controls->m_IndexParam1), SIGNAL(valueChanged(double)), this, SLOT(IndexParam1Changed(double)) );
     connect( (QObject*)(m_Controls->m_IndexParam2), SIGNAL(valueChanged(double)), this, SLOT(IndexParam2Changed(double)) );
 
     connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
 
     connect( (QObject*)(m_Controls->m_OpacitySlider), SIGNAL(spanChanged(double,double)), this, SLOT(OpacityChanged(double,double)) );
 
     connect((QObject*) m_Controls->m_Wire, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationWire()));
     connect((QObject*) m_Controls->m_Tube, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationTube()));
     connect((QObject*) m_Controls->m_Color, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationColor()));
     connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
     connect((QObject*) m_Controls->m_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
     connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
 
     connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
 
     connect((QObject*) m_Controls->m_PFWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(PFWidth(int)));
     connect((QObject*) m_Controls->m_PFColor, SIGNAL(clicked()), (QObject*) this, SLOT(PFColor()));
 
     connect((QObject*) m_Controls->m_TDI, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateTdi()));
 
     connect((QObject*) m_Controls->m_LineWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(LineWidthChanged(int)));
     connect((QObject*) m_Controls->m_TubeRadius, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(TubeRadiusChanged(int)));
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Activated()
 {
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
   QmitkFunctionality::Activated();
 }
 
 void QmitkControlVisualizationPropertiesView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkControlVisualizationPropertiesView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkControlVisualizationPropertiesView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
 
 // set diffusion image channel to b0 volume
 void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
 {
   mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
   if (dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData()))
   {
     mitk::DiffusionImage<short>::Pointer dimg = dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData());
 
     // if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
     // and hence we cannot set the Property directly to .front()
     int displayChannelPropertyValue = 0;
     if( dimg->GetB0Indices().size() > 0)
       displayChannelPropertyValue = dimg->GetB0Indices().front();
 
     notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
   }
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
 implement SelectionService Listener explicitly */
 void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
   // deactivate channel slider if no diffusion weighted image or tbss image is selected
   m_Controls->m_DisplayIndex->setVisible(false);
   m_Controls->m_DisplayIndexSpinBox->setVisible(false);
   m_Controls->label_channel->setVisible(false);
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     // check if node has data,
     // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == NULL)
       continue;
 
     if (node.IsNotNull() && (dynamic_cast<mitk::TbssImage*>(nodeData) ||
       dynamic_cast<mitk::DiffusionImage<short>*>(nodeData)))
     {
       m_Controls->m_DisplayIndex->setVisible(true);
       m_Controls->m_DisplayIndexSpinBox->setVisible(true);
       m_Controls->label_channel->setVisible(true);
     }
     else if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
     {
       if (m_Color.IsNotNull())
         m_Color->RemoveObserver(m_FiberBundleObserverTag);
 
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
       m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
       if (m_Color.IsNotNull())
         m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
     }
   }
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     // check if node has data,
     // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == NULL)
       continue;
 
     if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData)) )
     {
       if(m_NodeUsedForOdfVisualization.IsNotNull())
       {
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
       }
       m_NodeUsedForOdfVisualization = node;
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
       if(m_MultiWidget)
         m_MultiWidget->RequestUpdate();
 
       m_Controls->m_TSMenu->setVisible(false);  // deactivate mip etc. for tensor and q-ball images
       break;
     }
     else if( node.IsNotNull() && dynamic_cast<mitk::ConnectomicsNetwork*>(nodeData) )
       m_Controls->m_TSMenu->setVisible(false);
     else
       m_Controls->m_TSMenu->setVisible(true);
   }
 }
 
 mitk::DataStorage::SetOfObjects::Pointer
   QmitkControlVisualizationPropertiesView::ActiveSet(std::string classname)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
       mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
       i != m_CurrentSelection->End();
       ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
         // check if node has data,
         // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
         const mitk::BaseData* nodeData = node->GetData();
         if(nodeData == NULL)
           continue;
 
         if(QString(classname.c_str()).compare(nodeData->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     return set;
   }
 
   return 0;
 }
 
 void QmitkControlVisualizationPropertiesView::SetBoolProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, bool value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetBoolProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetIntProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, int value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFloatProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, float value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetFloatProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetLevelWindowProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, mitk::LevelWindow value)
 {
   if(set.IsNotNull())
   {
 
     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), prop);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetEnumProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, mitk::EnumerationProperty::Pointer value)
 {
   if(set.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 
 
 void QmitkControlVisualizationPropertiesView::DisplayIndexChanged(int dispIndex)
 {
 
   m_Controls->m_DisplayIndex->setValue(dispIndex);
   m_Controls->m_DisplayIndexSpinBox->setValue(dispIndex);
 
   QString label = "Channel %1";
   label = label.arg(dispIndex);
   m_Controls->label_channel->setText(label);
 
   std::vector<std::string> sets;
   sets.push_back("DiffusionImage");
   sets.push_back("TbssImage");
 
   std::vector<std::string>::iterator it = sets.begin();
   while(it != sets.end())
   {
     std::string s = *it;
     mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet(s);
 
     if(set.IsNotNull())
     {
 
       mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
       mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
       while ( itemiter != itemiterend )
       {
         (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
         ++itemiter;
       }
 
       //m_MultiWidget->RequestUpdate();
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     it++;
   }
 
 
 }
 
 void QmitkControlVisualizationPropertiesView::Reinit()
 {
   if (m_CurrentSelection)
   {
     mitk::DataNodeObject::Pointer nodeObj =
       m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
       mitk::RenderingManager::GetInstance()->InitializeViews(
-        basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+        basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::TextIntON()
 {
   if(m_TexIsOn)
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
   }
   else
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("DiffusionImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("QBallImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("Image");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   m_TexIsOn = !m_TexIsOn;
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
 {
   m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
   VisibleOdfsON(0);
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
 {
   m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
   VisibleOdfsON(1);
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
 {
   m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
   VisibleOdfsON(2);
 }
 
 bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
 {
 
   // for all 2D renderwindows of m_MultiWidget check alignment
   mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
   if (displayPlane.IsNull()) return false;
 
   mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
   if( currentImage == NULL )
   {
     MITK_ERROR << " Casting problems. Returning false";
     return false;
   }
 
   int affectedDimension(-1);
   int affectedSlice(-1);
   return !(DetermineAffectedImageSlice( currentImage, displayPlane, affectedDimension, affectedSlice ));
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON(int view)
 {
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   set = ActiveSet("TensorImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
   case 0:
     normMeth->SetNormalizationToMinMax();
     break;
   case 1:
     normMeth->SetNormalizationToMax();
     break;
   case 2:
     normMeth->SetNormalizationToNone();
     break;
   case 3:
     normMeth->SetNormalizationToGlobalMax();
     break;
   default:
     normMeth->SetNormalizationToMinMax();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   //  if(m_MultiWidget)
   //    m_MultiWidget->RequestUpdate();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
 {
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
   case 0:
     scaleBy->SetScaleByNothing();
     break;
   case 1:
     scaleBy->SetScaleByGFA();
     //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
   case 2:
     scaleBy->SetScaleByPrincipalCurvature();
     // commented in for SPIE paper, Principle curvature scaling
     //m_Controls->params_frame->setVisible(true);
     break;
 #endif
   default:
     scaleBy->SetScaleByNothing();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam1Changed(double param1)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam2Changed(double param2)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::OpacityChanged(double l, double u)
 {
   mitk::LevelWindow olw;
   olw.SetRangeMinMax(l*255, u*255);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("TensorImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("Image");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible(
     m_Controls->m_ScalingCheckbox->isChecked());
 
   if(!m_Controls->m_ScalingCheckbox->isChecked())
   {
     m_Controls->m_AdditionalScaling->setCurrentIndex(0);
     m_Controls->m_ScalingFactor->setValue(1.0);
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
 {
   if (m_SelectedNode)
   {
     bool currentMode;
     m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
     m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
 {
   if (m_SelectedNode)
   {
 
 
     float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
     m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
 {
   QString label = "Range %1";
   label = label.arg(value * 0.1);
   m_Controls->label_range->setText(label);
 
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationWire()
 {
   if(m_SelectedNode)
   {
     int width = m_Controls->m_LineWidth->value();
     m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationTube()
 {
   if(m_SelectedNode)
   {
     float radius = m_Controls->m_TubeRadius->value() / 100.0;
     m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
 {
   float color[3];
   m_SelectedNode->GetColor(color);
   m_Controls->m_Color->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color[0]*255.0));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[1]*255.0));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[2]*255.0));
   styleSheet.append(")");
   m_Controls->m_Color->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color[0], color[1], color[2]));
   mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
   fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
   m_SelectedNode->Modified();
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationColor()
 {
   if(m_SelectedNode)
   {
     QColor color = QColorDialog::getColor();
     if (!color.isValid())
       return;
 
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.blue()));
     styleSheet.append(")");
     m_Controls->m_Color->setStyleSheet(styleSheet);
 
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
     mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
     m_SelectedNode->Modified();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
 {
   if(m_SelectedNode)
   {
     MITK_INFO << "reset colorcoding to oBased";
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(255,255,255)";
     m_Controls->m_Color->setStyleSheet(styleSheet);
     //    m_SelectedNode->SetProperty("color",NULL);
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(1.0, 1.0, 1.0));
 
     mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED);
     fib->DoColorCodingOrientationBased();
     m_SelectedNode->Modified();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure && _PlanarFigure->GetGeometry2D())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       QmitkRenderWindow* RenderWindow1 =
         this->GetActiveStdMultiWidget()->GetRenderWindow1();
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
         PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       QmitkRenderWindow* RenderWindow2 =
         this->GetActiveStdMultiWidget()->GetRenderWindow2();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       QmitkRenderWindow* RenderWindow3 =
         this->GetActiveStdMultiWidget()->GetRenderWindow3();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       QmitkRenderWindow* RenderWindow4 =
         this->GetActiveStdMultiWidget()->GetRenderWindow4();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry
         * _PlaneGeometry =
         dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
         RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
         RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
         RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       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;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
           centerP, _PlaneGeometry->GetNormal());
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetInteractor()
 {
   typedef std::vector<mitk::DataNode*> Container;
   Container _NodeSet = this->GetDataManagerSelection();
   mitk::DataNode* node = 0;
   mitk::FiberBundleX* bundle = 0;
   mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   // finally add all nodes to the model
   for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(*it);
     bundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
 
     if(bundle)
     {
       bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
       if(bundleInteractor.IsNotNull())
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
       if(!m_Controls->m_Crosshair->isChecked())
       {
         m_Controls->m_Crosshair->setChecked(false);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
         m_CurrentPickingNode = 0;
       }
       else
       {
         m_Controls->m_Crosshair->setChecked(true);
         bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
         mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
         m_CurrentPickingNode = node;
       }
 
     }
   }
 
 }
 
 void QmitkControlVisualizationPropertiesView::PFWidth(int w)
 {
 
   double width = w/10.0;
   m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QString label = "Width %1";
   label = label.arg(width);
   m_Controls->label_pfwidth->setText(label);
 
 }
 
 void QmitkControlVisualizationPropertiesView::PFColor()
 {
 
   QColor color = QColorDialog::getColor();
   if (!color.isValid())
     return;
 
   m_Controls->m_PFColor->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::GenerateTdi()
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     if(!bundle)
       return;
 
     typedef float OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
 
     // run generator
     itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
     generator->SetFiberBundle(bundle);
     generator->SetOutputAbsoluteValues(true);
     generator->SetUpsamplingFactor(1);
     generator->Update();
 
     // get result
     OutImageType::Pointer outImg = generator->GetOutput();
 
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // to datastorage
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     QString name(m_SelectedNode->GetName().c_str());
     name += "_TDI";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
 
     GetDataStorage()->Add(node);
   }
 }
 
 void QmitkControlVisualizationPropertiesView::LineWidthChanged(int w)
 {
   QString label = "Width %1";
   label = label.arg(w);
   m_Controls->label_linewidth->setText(label);
   BundleRepresentationWire();
 }
 
 void QmitkControlVisualizationPropertiesView::TubeRadiusChanged(int r)
 {
   QString label = "Radius %1";
   label = label.arg(r / 100.0);
   m_Controls->label_tuberadius->setText(label);
   this->BundleRepresentationTube();
 }
 
 void QmitkControlVisualizationPropertiesView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
     GetSite()->GetWorkbenchWindow(), false);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
index 41d1db02d0..4c2a67fdd3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
@@ -1,814 +1,814 @@
 /*===================================================================
 
 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 "QmitkDiffusionDicomImportView.h"
 
 // qt includes
 #include <QFileDialog>
 
 // itk includes
 #include "itkTimeProbesCollectorBase.h"
 #include "itkGDCMSeriesFileNames.h"
 #include "itksys/SystemTools.hxx"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkMemoryUtilities.h"
 
 // diffusion module includes
 #include "mitkDicomDiffusionImageHeaderReader.h"
 #include "mitkDicomDiffusionImageReader.h"
 #include "mitkDiffusionImage.h"
 #include "mitkNrrdDiffusionImageWriter.h"
 
 #include "gdcmDirectory.h"
 #include "gdcmScanner.h"
 #include "gdcmSorter.h"
 #include "gdcmIPPSorter.h"
 #include "gdcmAttribute.h"
 #include "gdcmVersion.h"
 
 #include <QMessageBox>
 
 const std::string QmitkDiffusionDicomImport::VIEW_ID = "org.mitk.views.diffusiondicomimport";
 
 
 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(QObject* /*parent*/, const char* /*name*/)
   : QmitkFunctionality(), m_Controls(NULL), m_MultiWidget(NULL),
   m_OutputFolderName(""), m_OutputFolderNameSet(false)
 {
 }
 
 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkDiffusionDicomImport::~QmitkDiffusionDicomImport()
 {}
 
 void QmitkDiffusionDicomImport::CreateQtPartControl(QWidget *parent)
 {
   m_Parent = parent;
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkDiffusionDicomImportControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_DicomLoadRecursiveCheckbox->setChecked(true);
     m_Controls->m_DicomLoadAverageDuplicatesCheckbox->setChecked(false);
 
     m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(false);
     m_Controls->m_OverrideOptionCheckbox->setVisible(false);
 
     AverageClicked();
   }
 }
 
 
 
 void QmitkDiffusionDicomImport::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( m_Controls->m_AddFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadAddFolderNames()) );
     connect( m_Controls->m_DeleteFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadDeleteFolderNames()) );
     connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(DicomLoadStartLoad()) );
     connect( m_Controls->m_DicomLoadAverageDuplicatesCheckbox, SIGNAL(clicked()), this, SLOT(AverageClicked()) );
     connect( m_Controls->m_OutputSetButton, SIGNAL(clicked()), this, SLOT(OutputSet()) );
     connect( m_Controls->m_OutputClearButton, SIGNAL(clicked()), this, SLOT(OutputClear()) );
     connect( m_Controls->m_Remove, SIGNAL(clicked()), this, SLOT(Remove()) );
   }
 }
 
 
 void QmitkDiffusionDicomImport::Remove()
 {
   int i = m_Controls->listWidget->currentRow();
   m_Controls->listWidget->takeItem(i);
 }
 
 void QmitkDiffusionDicomImport::OutputSet()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_OutputFolderName = w->selectedFiles()[0];
   m_OutputFolderNameSet = true;
   m_Controls->m_OutputLabel->setText(m_OutputFolderName);
 
   // show file override option checkbox
   m_Controls->m_OverrideOptionCheckbox->setVisible(true);
 }
 
 void QmitkDiffusionDicomImport::OutputClear()
 {
   m_OutputFolderName = "";
   m_OutputFolderNameSet = false;
   m_Controls->m_OutputLabel->setText("... optional out-folder ...");
 
   // hide file override option checkbox - no output specified
   m_Controls->m_OverrideOptionCheckbox->setVisible(false);
 }
 
 void QmitkDiffusionDicomImport::AverageClicked()
 {
   m_Controls->m_Blur->setEnabled(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked());
 }
 
 void QmitkDiffusionDicomImport::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadDeleteFolderNames()
 {
   m_Controls->listWidget->clear();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadAddFolderNames()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->listWidget->addItems(w->selectedFiles());
 }
 
 bool SortBySeriesUID(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x000e> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x000e> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortByAcquisitionNumber(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x0012> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x0012> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortBySeqName(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0018, 0x0024> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0018, 0x0024> at2;
   at2.Set( ds2 );
 
   std::string str1 = at1.GetValue().Trim();
   std::string str2 = at2.GetValue().Trim();
   return std::lexicographical_compare(str1.begin(), str1.end(),
                                       str2.begin(), str2.end() );
 }
 
 void QmitkDiffusionDicomImport::Status(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.toAscii());
   MITK_INFO << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.c_str());
   MITK_INFO << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status);
   MITK_INFO << status;
 }
 
 void QmitkDiffusionDicomImport::Error(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.toAscii());
   MITK_ERROR << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.c_str());
   MITK_ERROR << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status);
   MITK_ERROR << status;
 }
 
 void QmitkDiffusionDicomImport::PrintMemoryUsage()
 {
   size_t processSize = mitk::MemoryUtilities::GetProcessMemoryUsage();
   size_t totalSize =  mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   float percentage = ( (float) processSize / (float) totalSize ) * 100.0;
   MITK_INFO << "Current memory usage: " << GetMemoryDescription( processSize, percentage );
 }
 
 std::string QmitkDiffusionDicomImport::FormatMemorySize( size_t size )
 {
   double val = size;
   std::string descriptor("B");
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "KB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "MB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "GB";
   }
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << descriptor;
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::FormatPercentage( double val )
 {
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << "%";
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::GetMemoryDescription( size_t processSize, float percentage )
 {
   std::ostringstream str;
   str << FormatMemorySize(processSize) << " (" << FormatPercentage( percentage ) <<")" ;
   return str.str();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadStartLoad()
 {
   itk::TimeProbesCollectorBase clock;
   bool imageSuccessfullySaved = true;
 
   try
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, NULL );
 
     if ( locale.compare(currLocale)!=0 )
     {
       try
       {
         MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
         setlocale(LC_ALL, locale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not set locale " << locale;
       }
     }
 
     int nrFolders = m_Controls->listWidget->count();
 
     if(!nrFolders)
     {
       Error(QString("No input folders were selected. ABORTING."));
       return;
     }
 
     Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
 
     PrintMemoryUsage();
     QString status;
     mitk::DataNode::Pointer node;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2*nrFolders);
 
 
     std::string folder = m_Controls->m_OutputLabel->text().toStdString();
 
 
     if(berry::Platform::IsWindows())
     {
       folder.append("\\import.log");
     }
     else
     {
       folder.append("/import.log");
     }
 
     ofstream logfile;
     if(m_OutputFolderNameSet) logfile.open(folder.c_str());
 
     while(m_Controls->listWidget->count())
     {
       // RETREIVE FOLDERNAME
       QListWidgetItem * item  = m_Controls->listWidget->takeItem(0);
       QString folderName = item->text();
 
       if(m_OutputFolderNameSet) logfile << "Reading " << folderName.toStdString() << '\n';
 
       // PARSING DIRECTORY
       PrintMemoryUsage();
       clock.Start(folderName.toAscii());
       std::vector<std::string> seriesUIDs(0);
       std::vector<std::vector<std::string> > seriesFilenames(0);
 
       Status("== Initial Directory Scan ==");
       if(m_OutputFolderNameSet) logfile << "== Initial Directory Scan ==\n";
 
       gdcm::Directory d;
       d.Load( folderName.toStdString().c_str(), true ); // recursive !
       const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
       const unsigned int ntotalfiles = l1.size();
       Status(QString(" ... found %1 different files").arg(ntotalfiles));
       if(m_OutputFolderNameSet)logfile << "...found " << ntotalfiles << " different files\n";
 
       Status("Scanning Headers");
       if(m_OutputFolderNameSet) logfile << "Scanning Headers\n";
 
       gdcm::Scanner s;
       const gdcm::Tag t1(0x0020,0x000d); // Study Instance UID
       const gdcm::Tag t2(0x0020,0x000e); // Series Instance UID
       const gdcm::Tag t5(0x0028, 0x0010); // number rows
       const gdcm::Tag t6(0x0028, 0x0011); // number cols
       s.AddTag( t1 );
       s.AddTag( t2 );
       s.AddTag( t5 );
       s.AddTag( t6 );
 
       bool b = s.Scan( d.GetFilenames() );
       if( !b )
       {
         Error("Scanner failed");
         if(m_OutputFolderNameSet )logfile << "ERROR: scanner failed\n";
         continue;
       }
 
       // Only get the DICOM files:
       gdcm::Directory::FilenamesType l2 = s.GetKeys();
 
 
 
       gdcm::Directory::FilenamesType::iterator it;
 
       for (it = l2.begin() ; it != l2.end(); ++it) {
         MITK_INFO << "-------FN " << *it;
       }
 
       const int nfiles = l2.size();
       if(nfiles < 1)
       {
         Error("No DICOM files found");
         if(m_OutputFolderNameSet)logfile << "ERROR: No DICOM files found\n";
         continue;
       }
       Status(QString(" ... successfully scanned %1 headers.").arg(nfiles));
       if(m_OutputFolderNameSet) logfile << "...succesfully scanned " << nfiles << " headers\n";
 
       Status("Sorting");
       if(m_OutputFolderNameSet) logfile << "Sorting\n";
 
       const gdcm::Scanner::ValuesType &values1 = s.GetValues(t1);
 
       int nvalues;
       if(m_Controls->m_DuplicateID->isChecked())
       {
         nvalues = 1;
       }
       else
       {
         nvalues = values1.size();
       }
 
       if(nvalues>1)
       {
         Error("Multiple sSeries tudies found. Please limit to 1 study per folder");
         if(m_OutputFolderNameSet) logfile << "Multiple series found. Limit to one. If you are convinced this is an error use the merge duplicate study IDs option \n";
         continue;
       }
 
       const gdcm::Scanner::ValuesType &values5 = s.GetValues(t5);
       const gdcm::Scanner::ValuesType &values6 = s.GetValues(t6);
       if(values5.size()>1 || values6.size()>1)
       {
         Error("Folder contains images of unequal dimensions that cannot be combined in one 3d volume. ABORTING.");
         if(m_OutputFolderNameSet) logfile << "Folder contains images of unequal dimensions that cannot be combined in one 3d volume. ABORTING\n.";
         continue;
       }
 
       const gdcm::Scanner::ValuesType &values2 = s.GetValues(t2);
 
 
       int nSeries;
       if(m_Controls->m_DuplicateID->isChecked())
       {
         nSeries = 1;
       }
       else
       {
         nSeries = values2.size();
       }
 
       gdcm::Directory::FilenamesType files;
       if(nSeries > 1)
       {
         gdcm::Sorter sorter;
         sorter.SetSortFunction( SortBySeriesUID );
         if (sorter.StableSort( l2 ))
         {
           files = sorter.GetFilenames();
         }
         else
         {
           Error("Loading of at least one DICOM file not successfull!");
           return;
         }
       }
       else
       {
         files = l2;
       }
 
       unsigned int nTotalAcquis = 0;
 
       if(nfiles % nSeries != 0)
       {
         Error("Number of files in series not equal, ABORTING");
         if(m_OutputFolderNameSet) logfile << "Number of files in series not equal, Some volumes are probably incomplete. ABORTING \n";
         continue;
       }
 
       int filesPerSeries = nfiles / nSeries;
 
       gdcm::Scanner::ValuesType::const_iterator it2 = values2.begin();
       for(int i=0; i<nSeries; i++)
       {
 
         gdcm::Directory::FilenamesType sub( files.begin() + i*filesPerSeries, files.begin() + (i+1)*filesPerSeries);
 
         gdcm::Scanner s;
         const gdcm::Tag t3(0x0020,0x0012);  // Acquisition ID
         const gdcm::Tag t4(0x0018,0x0024); // Sequence Name (in case acquisitions are equal for all)
         //        const gdcm::Tag t5(0x20,0x32) );    // Image Position (Patient)
         s.AddTag(t3);
         s.AddTag(t4);
         //        s.AddTag(t5);
 
         bool b = s.Scan( sub );
         if( !b )
         {
           Error("Scanner failed");
           if(m_OutputFolderNameSet) logfile << "Scanner failed\n";
           continue;
         }
 
         gdcm::Sorter subsorter;
         gdcm::Scanner::ValuesType::const_iterator it;
 
         const gdcm::Scanner::ValuesType &values3 = s.GetValues(t3);
         const gdcm::Scanner::ValuesType &values4 = s.GetValues(t4);;
         unsigned int nAcquis = values3.size();
 
         if(nAcquis > 1) // More than one element must have this tag (Not != )
         {
           subsorter.SetSortFunction( SortByAcquisitionNumber );
           it = values3.begin();
         }
         else if (values4.size() > 1)
         {
           nAcquis = values4.size();
           subsorter.SetSortFunction( SortBySeqName );
           it = values4.begin();
         }
         // Hotfix for Bug 14758, better fix by selecting always availible tags.
         else
         {
           Error("Sorting tags (0x0020,0x0012) and (0x0018,0x0024) missing, ABORTING");
           if(m_OutputFolderNameSet) logfile << "Sorting tags (0x0020,0x0012) and (0x0018,0x0024) missing, ABORTING\n";
           continue;
         }
         nTotalAcquis += nAcquis;
         subsorter.Sort( sub );
 
         if(filesPerSeries % nAcquis != 0)
         {
           Error("Number of files per acquisition not equal, ABORTING");
           if(m_OutputFolderNameSet) logfile << "Number of files per acquisition not equal, ABORTING \n";
           continue;
         }
 
         int filesPerAcqu = filesPerSeries / nAcquis;
 
         gdcm::Directory::FilenamesType subfiles = subsorter.GetFilenames();
         for ( unsigned int j = 0 ; j < nAcquis ; ++j )
         {
           std::string identifier = "serie_" + *it2 + "_acquis_" + *it++;
 
           gdcm::IPPSorter ippsorter;
           gdcm::Directory::FilenamesType ipplist((j)*filesPerAcqu+subfiles.begin(),(j+1)*filesPerAcqu+subfiles.begin());
           ippsorter.SetComputeZSpacing( true );
           if( !ippsorter.Sort( ipplist ) )
           {
             Error(QString("Failed to sort acquisition %1, ABORTING").arg(identifier.c_str()));
             if(m_OutputFolderNameSet) logfile << "Failed to sort acquisition " << identifier.c_str() << " , Aborting\n";
             continue;
           }
           const std::vector<std::string> & list = ippsorter.GetFilenames();
           seriesFilenames.push_back(list);
           seriesUIDs.push_back(identifier.c_str());
         }
         ++it2;
       }
 
       // Hot Fix for Bug 14758, checking if no file is acuired.
       if (nTotalAcquis < 1) // Test if zero, if true than error because no file was selected
       {
         Error("Nno files in acquisitions, ABORTING");
         if(m_OutputFolderNameSet) logfile << "Nno files in acquisitions, ABORTING \n";
         continue;
       }
       if(nfiles % nTotalAcquis != 0)
       {
         Error("Number of files per acquisition differs between series, ABORTING");
         if(m_OutputFolderNameSet) logfile << "Number of files per acquisition differs between series, ABORTING \n";
         continue;
       }
 
       int slices = nfiles/nTotalAcquis;
       Status(QString("Series is composed of %1 different 3D volumes with %2 slices.").arg(nTotalAcquis).arg(slices));
       if(m_OutputFolderNameSet) logfile << "Series is composed of " << nTotalAcquis << " different 3D volumes with " << slices << " slices\n";
 
       // READING HEADER-INFOS
       PrintMemoryUsage();
       Status(QString("Reading Headers %1").arg(folderName));
       if(m_OutputFolderNameSet) logfile << "Reading Headers "<< folderName.toStdString() << "\n";
 
       mitk::DicomDiffusionImageHeaderReader::Pointer headerReader;
       typedef short PixelValueType;
       typedef mitk::DicomDiffusionImageReader< PixelValueType, 3 > VolumesReader;
       VolumesReader::HeaderContainer inHeaders;
       unsigned int size2 = seriesUIDs.size();
       for ( unsigned int i = 0 ; i < size2 ; ++i )
       {
         // Hot Fix for Bug 14459, catching if no valid data in datafile.
         try
         {
           Status(QString("Reading header image #%1/%2").arg(i+1).arg(size2));
           headerReader = mitk::DicomDiffusionImageHeaderReader::New();
           headerReader->SetSeriesDicomFilenames(seriesFilenames[i]);
           headerReader->Update();
           inHeaders.push_back(headerReader->GetOutput());
         }
         catch (mitk::Exception e)
         {
           Error("Could not read file header, ABORTING");
           if(m_OutputFolderNameSet) logfile << e;
           continue;
         }
         //Status(std::endl;
       }
       mitk::ProgressBar::GetInstance()->Progress();
 
       //        // GROUP HEADERS
       //        mitk::GroupDiffusionHeadersFilter::Pointer grouper
       //            = mitk::GroupDiffusionHeadersFilter::New();
       //        mitk::GroupDiffusionHeadersFilter::OutputType outHeaders;
       //        grouper->SetInput(inHeaders);
       //        grouper->Update();
       //        outHeaders = grouper->GetOutput();
 
       // READ VOLUMES
       PrintMemoryUsage();
       if(m_OutputFolderNameSet) logfile << "Loading volumes\n";
       Status(QString("Loading Volumes %1").arg(folderName));
 
       VolumesReader::Pointer vReader = VolumesReader::New();
       VolumesReader::HeaderContainer hc = inHeaders;
 
       //        hc.insert(hc.end(), outHeaders[1].begin(), outHeaders[1].end() );
       //        hc.insert(hc.end(), outHeaders[2].begin(), outHeaders[2].end() );
       if(hc.size()>1)
       {
         vReader->SetHeaders(hc);
         vReader->Update();
         VolumesReader::OutputImageType::Pointer vecImage;
         vecImage = vReader->GetOutput();
         Status(QString("Volumes Loaded (%1)").arg(folderName));
 
         // CONSTRUCT CONTAINER WITH DIRECTIONS
         typedef vnl_vector_fixed< double, 3 >            GradientDirectionType;
         typedef itk::VectorContainer< unsigned int,
         GradientDirectionType >                  GradientDirectionContainerType;
         GradientDirectionContainerType::Pointer directions =
             GradientDirectionContainerType::New();
         std::vector<double> b_vals;
         double maxb = 0;
         for(unsigned int i=0; i<hc.size(); i++)
         {
           double bv = hc[i]->bValue;
           if(maxb<bv)
           {
             maxb = bv;
           }
           b_vals.push_back(bv);
         }
 
         for(unsigned int i=0; i<hc.size(); i++)
         {
           vnl_vector_fixed<double, 3> vect = hc[i]->DiffusionVector;
           vect.normalize();
           vect *= sqrt(b_vals[i]/maxb);
           directions->push_back(vect);
         }
 
         // DWI TO DATATREE
         PrintMemoryUsage();
         Status(QString("Initializing Diffusion Image"));
         if(m_OutputFolderNameSet) logfile << "Initializing Diffusion Image\n";
         typedef mitk::DiffusionImage<PixelValueType> DiffVolumesType;
         DiffVolumesType::Pointer diffImage = DiffVolumesType::New();
         diffImage->SetDirections(directions);
         diffImage->SetVectorImage(vecImage);
         diffImage->SetB_Value(maxb);
         diffImage->InitializeFromVectorImage();
         diffImage->UpdateBValueMap();
         Status(QString("Diffusion Image initialized"));
         if(m_OutputFolderNameSet) logfile << "Diffusion Image initialized\n";
 
         if(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked())
         {
           PrintMemoryUsage();
           Status(QString("Averaging gradient directions"));
           logfile << "Averaging gradient directions\n";
           diffImage->AverageRedundantGradients(m_Controls->m_Blur->value());
         }
 
         QString descr = QString("%1_%2_%3")
                         .arg(((inHeaders)[0])->seriesDescription.c_str())
                         .arg(((inHeaders)[0])->seriesNumber)
                         .arg(((inHeaders)[0])->patientName.c_str());
         descr = descr.trimmed();
         descr = descr.replace(" ", "_");
 
         if(!m_OutputFolderNameSet)
         {
           node=mitk::DataNode::New();
           node->SetData( diffImage );
           GetDefaultDataStorage()->Add(node);
           SetDwiNodeProperties(node, descr.toStdString().c_str());
           Status(QString("Image %1 added to datastorage").arg(descr));
         }
         else
         {
           typedef mitk::NrrdDiffusionImageWriter<PixelValueType> WriterType;
           WriterType::Pointer writer = WriterType::New();
           QString fullpath = QString("%1/%2.dwi")
                              .arg(m_OutputFolderName)
                              .arg(descr);
 
           // if the override option is not checked, we need to make sure that the current filepath
           // does not point to an existing file
           if( !(m_Controls->m_OverrideOptionCheckbox->isChecked()) )
           {
             QFile outputFile( fullpath );
 
             // generate new filename if file exists
             int file_counter = 0;
             while( outputFile.exists() )
             {
               // copy base name
               QString newdescr = descr;
 
               file_counter++;
               MITK_WARN << "The file "<< fullpath.toStdString() << " exists already.";
               QString appendix = QString("_%1").arg( QString::number(file_counter) );
               newdescr.append(appendix);
               fullpath = QString("%1/%2.dwi")
                   .arg(m_OutputFolderName)
                   .arg(newdescr);
 
               // set the new generated filename for next check
               outputFile.setFileName( fullpath );
             }
           }
           writer->SetFileName(fullpath.toStdString());
           writer->SetInput(diffImage);
           try
           {
             writer->Update();
           }
           catch (itk::ExceptionObject &ex)
           {
             imageSuccessfullySaved = false;
             Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
             logfile << QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()).toStdString() << "\n";
 
             node=mitk::DataNode::New();
             node->SetData( diffImage );
             GetDefaultDataStorage()->Add(node);
             SetDwiNodeProperties(node, descr.toStdString().c_str());
             Status(QString("Image %1 added to datastorage").arg(descr));
             logfile << "Image " << descr.toStdString() << " added to datastorage\n";
             continue ;
           }
           Status(QString("Image %1 written to disc (%1)").arg(fullpath.toStdString().c_str()));
           logfile << "Image " << fullpath.toStdString() << "\n";
         }
       }
       else
       {
         Status(QString("No diffusion information found (%1)").arg(folderName));
         if(m_OutputFolderNameSet) logfile << "No diffusion information found  "<< folderName.toStdString();
       }
 
       Status(QString("Finished processing %1 with memory:").arg(folderName));
       if(m_OutputFolderNameSet) logfile << "Finished processing " << folderName.toStdString() << "\n";
       PrintMemoryUsage();
       clock.Stop(folderName.toAscii());
       mitk::ProgressBar::GetInstance()->Progress();
       int lwidget = m_Controls->listWidget->count();
       std::cout << lwidget <<std::endl;
 
       logfile << "\n";
 
     }
 
     logfile.close();
 
     Status("Timing information");
     clock.Report();
 
     if(!m_OutputFolderNameSet && node.IsNotNull())
     {
       mitk::BaseData::Pointer basedata = node->GetData();
       if (basedata.IsNotNull())
       {
         mitk::RenderingManager::GetInstance()->InitializeViews(
-            basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+            basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     try
     {
       MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
       setlocale(LC_ALL, currLocale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not reset locale " << currLocale;
     }
   }
   catch (itk::ExceptionObject &ex)
   {
     Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
     return ;
   }
 
   if (!imageSuccessfullySaved)
     QMessageBox::warning(NULL,"WARNING","One or more files could not be saved! The according files where moved to the datastorage.");
   Status(QString("Finished import with memory:"));
 
   PrintMemoryUsage();
 }
 
 void QmitkDiffusionDicomImport::SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
 
   node->SetProperty( "IsDWIRawVolume", mitk::BoolProperty::New( true ) );
 
   // set foldername as string property
   mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
   node->SetProperty( "name", nameProp );
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
index beca52cd6e..774d8968e3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
@@ -1,496 +1,496 @@
 /*===================================================================
 
 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
 #include "QmitkDwiSoftwarePhantomView.h"
 
 // MITK
 #include <mitkDiffusionImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <itkDwiPhantomGenerationFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkDwiSoftwarePhantomView::VIEW_ID = "org.mitk.views.dwisoftwarephantomview";
 
 QmitkDwiSoftwarePhantomView::QmitkDwiSoftwarePhantomView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
 {
 
 }
 
 // Destructor
 QmitkDwiSoftwarePhantomView::~QmitkDwiSoftwarePhantomView()
 {
 
 }
 
 
 void QmitkDwiSoftwarePhantomView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkDwiSoftwarePhantomViewControls;
         m_Controls->setupUi( parent );
         m_Controls->m_SignalRegionBox->setVisible(false);
 
         connect((QObject*) m_Controls->m_GeneratePhantomButton, SIGNAL(clicked()), (QObject*) this, SLOT(GeneratePhantom()));
         connect((QObject*) m_Controls->m_SimulateBaseline, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnSimulateBaselineToggle(int)));
     }
 }
 
 QmitkDwiSoftwarePhantomView::GradientListType QmitkDwiSoftwarePhantomView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     vnl_vector<double> theta; theta.set_size(NPoints);
 
     vnl_vector<double> phi; phi.set_size(NPoints);
 
     double C = sqrt(4*M_PI);
 
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
 
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     GradientListType pointshell;
 
     int numB0 = NPoints/10;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkDwiSoftwarePhantomView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkDwiSoftwarePhantomView::OnSimulateBaselineToggle(int state)
 {
     if (state)
     {
         m_Controls->m_NoiseLabel->setText("Noise Variance:");
         m_Controls->m_NoiseLevel->setValue(1.0/(m_Controls->m_NoiseLevel->value()*m_Controls->m_NoiseLevel->value()));
         m_Controls->m_NoiseLevel->setToolTip("Variance of Rician noise.");
     }
     else
     {
         m_Controls->m_NoiseLabel->setText("SNR:");
         if (m_Controls->m_NoiseLevel->value()>0)
             m_Controls->m_NoiseLevel->setValue(1.0/(sqrt(m_Controls->m_NoiseLevel->value())));
         else
             m_Controls->m_NoiseLevel->setValue(0.0001);
         m_Controls->m_NoiseLevel->setToolTip("Signal to noise ratio (for values > 99, no noise at all is added to the image).");
     }
 }
 
 void QmitkDwiSoftwarePhantomView::GeneratePhantom()
 {
     typedef itk::DwiPhantomGenerationFilter< short > FilterType;
     FilterType::GradientListType gradientList;
 
     m_SignalRegions.clear();
     for (int i=0; i<m_SignalRegionNodes.size(); i++)
     {
         mitk::Image::Pointer mitkBinaryImg = dynamic_cast<mitk::Image*>(m_SignalRegionNodes.at(i)->GetData());
         ItkUcharImgType::Pointer signalRegion = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(mitkBinaryImg, signalRegion);
         m_SignalRegions.push_back(signalRegion);
     }
 
     gradientList = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
 
     //    switch(m_Controls->m_NumGradientsBox->value())
     //    {
     //    case 0:
     //        gradientList = MakeGradientList<12>();
     //        break;
     //    case 1:
     //        gradientList = MakeGradientList<42>();
     //        break;
     //    case 2:
     //        gradientList = MakeGradientList<92>();
     //        break;
     //    case 3:
     //        gradientList = MakeGradientList<162>();
     //        break;
     //    case 4:
     //        gradientList = MakeGradientList<252>();
     //        break;
     //    case 5:
     //        gradientList = MakeGradientList<362>();
     //        break;
     //    case 6:
     //        gradientList = MakeGradientList<492>();
     //        break;
     //    case 7:
     //        gradientList = MakeGradientList<642>();
     //        break;
     //    case 8:
     //        gradientList = MakeGradientList<812>();
     //        break;
     //    case 9:
     //        gradientList = MakeGradientList<1002>();
     //        break;
     //    default:
     //        gradientList = MakeGradientList<92>();
     //    }
 
     double bVal = m_Controls->m_TensorsToDWIBValueEdit->value();
     itk::ImageRegion<3> imageRegion;
     imageRegion.SetSize(0, m_Controls->m_SizeX->value());
     imageRegion.SetSize(1, m_Controls->m_SizeY->value());
     imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
     mitk::Vector3D spacing;
     spacing[0] = m_Controls->m_SpacingX->value();
     spacing[1] = m_Controls->m_SpacingY->value();
     spacing[2] = m_Controls->m_SpacingZ->value();
 
     FilterType::Pointer filter = FilterType::New();
     filter->SetGradientList(gradientList);
     filter->SetBValue(bVal);
     filter->SetNoiseVariance(m_Controls->m_NoiseLevel->value());
     filter->SetImageRegion(imageRegion);
     filter->SetSpacing(spacing);
     filter->SetSignalRegions(m_SignalRegions);
     filter->SetGreyMatterAdc(m_Controls->m_GmAdc->value());
 
     std::vector< float >                            tensorFA;
     std::vector< float >                            tensorADC;
     std::vector< float >                            tensorWeight;
     std::vector< vnl_vector_fixed<double, 3> >      tensorDirection;
     for (int i=0; i<m_SpinFa.size(); i++)
     {
         tensorFA.push_back(m_SpinFa.at(i)->value());
         tensorADC.push_back(m_SpinAdc.at(i)->value());
         vnl_vector_fixed<double, 3> dir;
         dir[0] = m_SpinX.at(i)->value();
         dir[1] = m_SpinY.at(i)->value();
         dir[2] = m_SpinZ.at(i)->value();
         dir.normalize();
         tensorDirection.push_back(dir);
         tensorWeight.push_back(m_SpinWeight.at(i)->value());
     }
     filter->SetTensorFA(tensorFA);
     filter->SetTensorADC(tensorADC);
     filter->SetTensorWeight(tensorWeight);
     filter->SetTensorDirection(tensorDirection);
     if (!m_Controls->m_SimulateBaseline->isChecked())
         filter->SetSimulateBaseline(false);
     else
         filter->SetSimulateBaseline(true);
     filter->Update();
 
     mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
     image->SetVectorImage( filter->GetOutput() );
     image->SetB_Value(bVal);
     image->SetDirections(gradientList);
     image->InitializeFromVectorImage();
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
     node->SetName(m_Controls->m_ImageName->text().toStdString());
     GetDataStorage()->Add(node);
 
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
         mitk::RenderingManager::GetInstance()->InitializeViews(
-                    basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+                    basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( numDirImage.GetPointer() );
         image->SetVolume( numDirImage->GetBufferPointer() );
         mitk::DataNode::Pointer node2 = mitk::DataNode::New();
         node2->SetData(image);
         QString name(m_Controls->m_ImageName->text());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputSnrImageBox->isChecked())
     {
         ItkFloatImgType::Pointer snrImage = filter->GetSNRImage();
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( snrImage.GetPointer() );
         image->SetVolume( snrImage->GetBufferPointer() );
         mitk::DataNode::Pointer node2 = mitk::DataNode::New();
         node2->SetData(image);
         QString name(m_Controls->m_ImageName->text());
         name += "_SNR";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_SignalRegionNodes.size()==0)
         return;
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef FilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             FilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetData(img);
             QString name(m_Controls->m_ImageName->text());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Geometry3D::Pointer geometry = image->GetGeometry();
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
         directions->SetGeometry(geometry);
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(directions);
         QString name(m_Controls->m_ImageName->text());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkDwiSoftwarePhantomView::UpdateGui()
 {
     if (!m_SignalRegionNodes.empty())
     {
         m_Controls->m_SignalRegionBox->setVisible(true);
         m_Controls->m_Instruction->setVisible(false);
     }
     else
     {
         m_Controls->m_SignalRegionBox->setVisible(false);
         m_Controls->m_Instruction->setVisible(true);
     }
 
     QLayout* layout = m_Controls->m_SignalRegionBox->layout();
 
     for (int i=0; i<m_Labels.size(); i++)
     {
         delete m_Labels.at(i);
     }
     for (int i=0; i<m_SpinFa.size(); i++)
     {
         delete m_SpinFa.at(i);
         delete m_SpinAdc.at(i);
         delete m_SpinX.at(i);
         delete m_SpinY.at(i);
         delete m_SpinZ.at(i);
         delete m_SpinWeight.at(i);
     }
     m_Labels.clear();
     m_SpinFa.clear();
     m_SpinAdc.clear();
     m_SpinX.clear();
     m_SpinY.clear();
     m_SpinZ.clear();
     m_SpinWeight.clear();
 
     if (layout)
         delete layout;
 
     QGridLayout* newlayout = new QGridLayout();
 
     m_Controls->m_SignalRegionBox->setLayout(newlayout);
 
     if (!m_SignalRegionNodes.empty())
     {
         QLabel* label1 = new QLabel("Image");
         newlayout->addWidget(label1,0,0);
         m_Labels.push_back(label1);
         QLabel* label2 = new QLabel("FA");
         newlayout->addWidget(label2,0,1);
         m_Labels.push_back(label2);
         QLabel* label3 = new QLabel("ADC");
         newlayout->addWidget(label3,0,2);
         m_Labels.push_back(label3);
         QLabel* label4 = new QLabel("X");
         newlayout->addWidget(label4,0,03);
         m_Labels.push_back(label4);
         QLabel* label5 = new QLabel("Y");
         newlayout->addWidget(label5,0,4);
         m_Labels.push_back(label5);
         QLabel* label6 = new QLabel("Z");
         newlayout->addWidget(label6,0,5);
         m_Labels.push_back(label6);
         QLabel* label7 = new QLabel("Weight");
         newlayout->addWidget(label7,0,6);
         m_Labels.push_back(label7);
     }
     for (int i=0; i<m_SignalRegionNodes.size(); i++)
     {
         QLabel* label = new QLabel(m_SignalRegionNodes.at(i)->GetName().c_str());
         newlayout->addWidget(label,i+1,0);
         m_Labels.push_back(label);
 
         QDoubleSpinBox* spinFa = new QDoubleSpinBox();
         spinFa->setValue(0.7);
         spinFa->setMinimum(0);
         spinFa->setMaximum(1);
         spinFa->setSingleStep(0.1);
         newlayout->addWidget(spinFa,i+1,1);
         m_SpinFa.push_back(spinFa);
 
         QDoubleSpinBox* spinAdc = new QDoubleSpinBox();
         newlayout->addWidget(spinAdc,i+1,2);
         spinAdc->setMinimum(0);
         spinAdc->setMaximum(1);
         spinAdc->setSingleStep(0.001);
         spinAdc->setDecimals(3);
         spinAdc->setValue(0.001); ///// ???????????????????????????
         m_SpinAdc.push_back(spinAdc);
 
         QDoubleSpinBox* spinX = new QDoubleSpinBox();
         newlayout->addWidget(spinX,i+1,3);
         spinX->setValue(1);
         spinX->setMinimum(-1);
         spinX->setMaximum(1);
         spinX->setSingleStep(0.1);
         m_SpinX.push_back(spinX);
 
         QDoubleSpinBox* spinY = new QDoubleSpinBox();
         newlayout->addWidget(spinY,i+1,4);
         spinY->setMinimum(-1);
         spinY->setMaximum(1);
         spinY->setSingleStep(0.1);
         m_SpinY.push_back(spinY);
 
         QDoubleSpinBox* spinZ = new QDoubleSpinBox();
         newlayout->addWidget(spinZ,i+1,5);
         spinZ->setMinimum(-1);
         spinZ->setMaximum(1);
         spinZ->setSingleStep(0.1);
         m_SpinZ.push_back(spinZ);
 
         QDoubleSpinBox* spinWeight = new QDoubleSpinBox();
         newlayout->addWidget(spinWeight,i+1,6);
         spinWeight->setMinimum(0);
         spinWeight->setMaximum(1);
         spinWeight->setSingleStep(0.1);
         spinWeight->setValue(1.0);
         m_SpinWeight.push_back(spinWeight);
     }
 }
 
 void QmitkDwiSoftwarePhantomView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkDwiSoftwarePhantomView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkDwiSoftwarePhantomView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_SignalRegionNodes.clear();
 
     // iterate all selected objects, adjust warning visibility
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_SignalRegionNodes.push_back(node);
         }
     }
     UpdateGui();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
index 4c80a721b4..b5f575c857 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
@@ -1,1816 +1,1816 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 //=========FOR TESTING==========
 //random generation, number of points equal requested points
 
 
 
 // Blueberry application and interaction service
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberBundleDeveloperView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QTimer>
 
 // MITK
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 
-//===needed when timeSlicedGeometry is null to invoke rendering mechansims ====
+//===needed when timeGeometry is null to invoke rendering mechansims ====
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include "mitkModuleRegistry.h"
 
 
 // VTK
 #include <vtkPointSource.h> //for randomized FiberStructure
 #include <vtkPolyLine.h>  //for fiberStructure
 #include <vtkCellArray.h> //for fiberStructure
 #include <vtkMatrix4x4.h> //for geometry
 
 //ITK
 #include <itkTimeProbe.h>
 
 //==============================================
 //======== W O R K E R S ____ S T A R T ========
 //==============================================
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --generate FiberIDs--*/
 
 QmitkFiberIDWorker::QmitkFiberIDWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberIDWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     m_itemPackage.st_FBX->GenerateFiberIds();
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * -- extract fibers by given PlanarFigure --*/
 QmitkFiberExtractorWorker::QmitkFiberExtractorWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberExtractorWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerExtractFibers->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     std::vector<long> fibIds = m_itemPackage.st_FBX->ExtractFiberIdSubset(m_itemPackage.st_PlanarFigure);
 
     //generate new fiberbundle by fiber iDs
     vtkSmartPointer<vtkPolyData> newFBPolyData = m_itemPackage.st_FBX->GeneratePolyDataByIds(fibIds);
 
     // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
     (m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(newFBPolyData);
 
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerExtractFibers->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --set FA values to fiberbundle--*/
 QmitkFiberColoringWorker::QmitkFiberColoringWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage)
     , m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberColoringWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
 
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerColorCoding->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     if(m_itemPackage.st_Controls->radioButton_ColorOrient->isChecked()) {
         m_itemPackage.st_FBX->DoColorCodingOrientationBased();
 
     } else if(m_itemPackage.st_Controls->radioButton_ColorFA->isChecked()) {
         m_itemPackage.st_FBX->DoColorCodingFaBased();
 
     } else if(m_itemPackage.st_Controls->radioButton_OpacityFA->isChecked()) {
         //        m_itemPackage.st_FBX->SetColorCoding("");
         m_itemPackage.st_PassedDataNode->SetOpacity(0.999);
         m_itemPackage.st_FBX->DoUseFaFiberOpacity();
     } else if(m_itemPackage.st_Controls->radioButton_ColorCustom->isChecked()){
         m_itemPackage.st_FBX->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
     }
 
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerColorCoding->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 QmitkFiberFeederFAWorker::QmitkFiberFeederFAWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberFeederFAWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
      * accurate time measurement using ITK timeProbe */
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerSetFA->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     mitk::Image::Pointer FAImg = dynamic_cast<mitk::Image*>(m_itemPackage.st_PassedDataNode->GetData());
     if(FAImg.IsNotNull())
         m_itemPackage.st_FBX->SetFAMap(FAImg);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerSetFA->setText( QString::number(clock.GetTotal()) );
 
     disconnect(m_itemPackage.st_FancyGUITimer1);
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --generate random fibers--*/
 QmitkFiberGenerateRandomWorker::QmitkFiberGenerateRandomWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberGenerateRandomWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS */
     //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
     m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing, generateRandomFibers
     int numOfFibers = m_itemPackage.st_Controls->boxFiberNumbers->value();
     int distrRadius = m_itemPackage.st_Controls->boxDistributionRadius->value();
     int numOfPoints = numOfFibers * distrRadius;
 
     std::vector< std::vector<int> > fiberStorage;
     for (int i=0; i<numOfFibers; ++i) {
         std::vector<int> a;
         fiberStorage.push_back( a );
     }
 
     /* Generate Point Cloud */
     vtkSmartPointer<vtkPointSource> randomPoints = vtkSmartPointer<vtkPointSource>::New();
     randomPoints->SetCenter(0.0, 0.0, 0.0);
     randomPoints->SetNumberOfPoints(numOfPoints);
     randomPoints->SetRadius(distrRadius);
     randomPoints->Update();
     vtkPoints* pnts = randomPoints->GetOutput()->GetPoints();
 
     /* ASSIGN EACH POINT TO A RANDOM FIBER */
     srand((unsigned)time(0)); // init randomizer
     for (int i=0; i<pnts->GetNumberOfPoints(); ++i) {
 
         //generate random number between 0 and numOfFibers-1
         int random_integer;
         random_integer = (rand()%numOfFibers);
 
         //add current point to random fiber
         fiberStorage.at(random_integer).push_back(i);
         //    MITK_INFO << "point" << i << " |" << pnts->GetPoint(random_integer)[0] << "|" << pnts->GetPoint(random_integer)[1]<< "|" << pnts->GetPoint(random_integer)[2] << "| into fiber" << random_integer;
     }
 
     // initialize accurate time measurement
     itk::TimeProbe clock;
     clock.Start();
 
     /* GENERATE VTK POLYLINES OUT OF FIBERSTORAGE */
     vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New(); // Host vtkPolyLines
     linesCell->Allocate(pnts->GetNumberOfPoints()*2); //allocate for each cellindex also space for the pointId, e.g. [idx | pntID]
     for (long i=0; i<fiberStorage.size(); ++i)
     {
         std::vector<int> singleFiber = fiberStorage.at(i);
         vtkSmartPointer<vtkPolyLine> fiber = vtkSmartPointer<vtkPolyLine>::New();
         fiber->GetPointIds()->SetNumberOfIds((int)singleFiber.size());
 
         for (long si=0; si<singleFiber.size(); ++si)
         {  //hopefully long to double works fine in VTK ;-)
             fiber->GetPointIds()->SetId( si, singleFiber.at(si) );
         }
 
         linesCell->InsertNextCell(fiber);
     }
 
     /* checkpoint for cellarray allocation */
     if ( (linesCell->GetSize()/pnts->GetNumberOfPoints()) != 2 ) //e.g. size: 12, number of points:6 .... each cell hosts point ids (6 ids) + cell index for each idPoint. 6 * 2 = 12
     {
         MITK_INFO << "RANDOM FIBER ALLOCATION CAN NOT BE TRUSTED ANYMORE! Correct leak or remove command: linesCell->Allocate(pnts->GetNumberOfPoints()*2) but be aware of possible loss in performance.";
     }
 
     /* HOSTING POLYDATA FOR RANDOM FIBERSTRUCTURE */
     vtkSmartPointer<vtkPolyData> PDRandom = vtkSmartPointer<vtkPolyData>::New(); //could also be a standard pointer instead of smartpointer cuz ther is no need to delete because data is managed in datastorage.
     PDRandom->SetPoints(pnts);
     PDRandom->SetLines(linesCell);
 
     // accurate timer measurement stop
     clock.Stop();
     //MITK_INFO << "=====Assambling random Fibers to Polydata======\nMean: " << clock.GetMean() << " Total: " << clock.GetTotal() << std::endl;
 
     // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
     (m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(PDRandom);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --update GUI elements of thread monitor--
  * implementation not thread safe, not needed so far because
  * there exists only 1 thread for fiberprocessing
  * for threadsafety, you need to implement checking mechanisms in methods "::threadFor...." */
 QmitkFiberThreadMonitorWorker::QmitkFiberThreadMonitorWorker( QThread* hostingThread, Package4WorkingThread itemPackage )
     : m_itemPackage(itemPackage)
     , m_hostingThread(hostingThread)
     , m_pixelstepper(10) //for next rendering call, move object 10px
     , m_steppingDistance(220) //use only a multiple value of pixelstepper, x-axis border for fancy stuff
 {
 
 
     //set timers
     m_thtimer_initMonitor = new QTimer;
     m_thtimer_initMonitor->setInterval(10);
 
     m_thtimer_initMonitorSetFinalPosition = new QTimer;
     m_thtimer_initMonitorSetFinalPosition->setInterval(10);
 
     m_thtimer_initMonitorSetMasks = new QTimer;
     m_thtimer_initMonitorSetFinalPosition->setInterval(10);
 
 
     m_thtimer_threadStarted  = new QTimer;
     m_thtimer_threadStarted->setInterval(50);
 
     m_thtimer_threadFinished = new QTimer;
     m_thtimer_threadFinished->setInterval(50);
 
     m_thtimer_threadTerminated = new QTimer;
     m_thtimer_threadTerminated->setInterval(50);
 
 
 
     connect (m_thtimer_initMonitor, SIGNAL( timeout()), this, SLOT( fancyMonitorInitialization() ) );
     connect ( m_thtimer_initMonitorSetFinalPosition, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationFinalPos() ) );
     connect ( m_thtimer_initMonitorSetMasks, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationMask() ) );
 
     connect (m_thtimer_threadStarted, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadStarted() ) );
     connect (m_thtimer_threadFinished, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadFinished() ) );
     connect (m_thtimer_threadTerminated, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadTerminated() ) );
 
     //first, the current text shall turn transparent
     m_decreaseOpacity_threadStarted = true;
     m_decreaseOpacity_threadFinished = true;
     m_decreaseOpacity_threadTerminated = true;
 
 
 
 
 }
 void QmitkFiberThreadMonitorWorker::run()
 {
 
 }
 
 void QmitkFiberThreadMonitorWorker::initializeMonitor()
 {
     //fancy configuration of animation start
     mitk::Point2D pntOpen;
     pntOpen[0] = 118;
     pntOpen[1] = 10;
 
     mitk::Point2D headPos;
     headPos[0] = 19;
     headPos[1] = 10;
 
     mitk::Point2D statusPos;
     statusPos[0] = 105;
     statusPos[1] = 23;
 
     mitk::Point2D startedPos;
     startedPos[0] = 68;
     startedPos[1] = 10;
 
     mitk::Point2D finishedPos;
     finishedPos[0] = 143;
     finishedPos[1] = 10;
 
     mitk::Point2D terminatedPos;
     terminatedPos[0] = 240;
     terminatedPos[1] = 10;
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setHeadingPosition(headPos);
     m_itemPackage.st_FBX_Monitor->setMaskPosition(headPos);
     m_itemPackage.st_FBX_Monitor->setStatusPosition(statusPos);
     m_itemPackage.st_FBX_Monitor->setStartedPosition(startedPos);
     m_itemPackage.st_FBX_Monitor->setFinishedPosition(finishedPos);
     m_itemPackage.st_FBX_Monitor->setTerminatedPosition(terminatedPos);
 
 
     m_thtimer_initMonitor->start();
 }
 
 void QmitkFiberThreadMonitorWorker::setThreadStatus(QString status)
 {
     m_itemPackage.st_FBX_Monitor->setStatus(status);
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 }
 
 /* Methods to set status of running threads
  * Following three methods are usually called
  - before a thread starts and
  - a thread is finished or terminated */
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingStarted()
 {
     if(!m_thtimer_threadStarted->isActive())  {
         m_thtimer_threadStarted->start();
     } else {
         //fast change without fancy stuff, needed to keep threaddebugger info up to date
         int counter = m_itemPackage.st_FBX_Monitor->getStarted();
         m_itemPackage.st_FBX_Monitor->setStarted(++counter);
 
     }
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingFinished()
 {
     if(!m_thtimer_threadFinished->isActive())  {
         m_thtimer_threadFinished->start();
     } else {
         //fast change without fancy stuff
         int counter = m_itemPackage.st_FBX_Monitor->getFinished();
         m_itemPackage.st_FBX_Monitor->setFinished(++counter);
 
     }
 
 }
 
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingTerminated()
 {
     if(!m_thtimer_threadTerminated->isActive())  {
         m_thtimer_threadTerminated->start();
     } else {
         //fast change without fancy stuff
         int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
         m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
 
     }
 
 }
 
 
 /* Helper methods for fancy fading efx for thread monitor */
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadStarted()
 {
 
     if (m_decreaseOpacity_threadStarted) {
         int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
         m_itemPackage.st_FBX_Monitor->setStartedOpacity( --startedOpacity );
 
         if (startedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getStarted();
             m_itemPackage.st_FBX_Monitor->setStarted(++counter);
             m_decreaseOpacity_threadStarted = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
         m_itemPackage.st_FBX_Monitor->setStartedOpacity( ++startedOpacity );
 
         if (startedOpacity >= 10) {
             m_thtimer_threadStarted->stop();
             m_decreaseOpacity_threadStarted = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadFinished()
 {
     if (m_decreaseOpacity_threadFinished) {
         int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
         m_itemPackage.st_FBX_Monitor->setFinishedOpacity( --finishedOpacity );
 
         if (finishedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getFinished();
             m_itemPackage.st_FBX_Monitor->setFinished(++counter);
             m_decreaseOpacity_threadFinished = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
         m_itemPackage.st_FBX_Monitor->setFinishedOpacity( ++finishedOpacity );
 
         if (finishedOpacity >= 10) {
             m_thtimer_threadFinished->stop();
             m_decreaseOpacity_threadFinished = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadTerminated()
 {
     if (m_decreaseOpacity_threadTerminated) {
         int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
         m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( --terminatedOpacity );
 
         if (terminatedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
             m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
             m_decreaseOpacity_threadTerminated = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
         m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( ++terminatedOpacity );
 
         if (terminatedOpacity >= 10) {
             m_thtimer_threadTerminated->stop();
             m_decreaseOpacity_threadTerminated = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitialization()
 {
 
     mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition(); //possible bottleneck, set pntClose to member
     mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition(); //possible bottleneck, set pntClose to member
 
     pntClose[0] += m_pixelstepper;
     pntOpen[0] -= m_pixelstepper;
     //MITK_INFO << pntClose[0] << " " << pntOpen[0];
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
 
     int opacity = m_itemPackage.st_FBX_Monitor->getHeadingOpacity() + 1;
     if (opacity > 10)
         opacity = 10;
     m_itemPackage.st_FBX_Monitor->setHeadingOpacity(opacity);
 
 
     if (pntClose[0] >= m_steppingDistance)
     {
         if (m_itemPackage.st_FBX_Monitor->getHeadingOpacity() != 10 )
         {
             m_itemPackage.st_FBX_Monitor->setHeadingOpacity(10);
             m_itemPackage.st_ThreadMonitorDataNode->Modified();
             m_itemPackage.st_MultiWidget->RequestUpdate();
         }
 
         m_thtimer_initMonitor->stop();
 
         //position them to obt y=25
         m_thtimer_initMonitorSetFinalPosition->start();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationFinalPos()
 {
     //get y pos of
     mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition();
     mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition();
     mitk::Point2D pntHead = m_itemPackage.st_FBX_Monitor->getHeadingPosition();
 
     pntClose[1] += 5;
     pntOpen[1] += 5;
     pntHead[1] += 5;
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setHeadingPosition(pntHead);
 
 
     if (pntClose[1] >= 35) { //35 = y position
         m_thtimer_initMonitorSetFinalPosition->stop();
         //now init mask of labels
         m_thtimer_initMonitorSetMasks->start();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationMask()
 {
     //increase opacity
     int opacity = m_itemPackage.st_FBX_Monitor->getMaskOpacity();
     opacity++;
     m_itemPackage.st_FBX_Monitor->setMaskOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setStartedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setFinishedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setTerminatedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setStatusOpacity(opacity);
 
     if (opacity >=10) {
         m_thtimer_initMonitorSetMasks->stop();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 }
 
 //==============================================
 //======== W O R K E R S ________ E N D ========
 //==============================================
 
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //                   HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW IMPLEMENTATION
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 
 
 
 const std::string QmitkFiberBundleDeveloperView::VIEW_ID = "org.mitk.views.fiberbundledeveloper";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 
 QmitkFiberBundleDeveloperView::QmitkFiberBundleDeveloperView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_FiberIDGenerator( NULL)
     , m_GeneratorFibersRandom( NULL )
     , m_FiberFeederFASlave( NULL )
     , m_FiberColoringSlave(NULL)
     , m_FiberExtractor(NULL)
     , m_fiberMonitorIsOn( false )
     , m_CircleCounter( 0 )
     , m_suppressSignal(false)
 {
     m_hostThread = new QThread;
     m_threadInProgress = false;
 
 }
 
 // Destructor
 QmitkFiberBundleDeveloperView::~QmitkFiberBundleDeveloperView()
 {
     //m_FiberBundleX->Delete(); using weakPointer, therefore no delete necessary
     delete m_hostThread;
 }
 
 
 void QmitkFiberBundleDeveloperView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done in QtDesigner, etc.
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberBundleDeveloperViewControls;
         m_Controls->setupUi( parent );
 
         /*=========INITIALIZE BUTTON CONFIGURATION ================*/
         m_Controls->radioButton_directionX->setEnabled(false);
         m_Controls->radioButton_directionY->setEnabled(false);
         m_Controls->radioButton_directionZ->setEnabled(false);
         m_Controls->buttonGenerateFiberIds->setEnabled(false);
         m_Controls->buttonGenerateFibers->setEnabled(true);
         m_Controls->buttonColorFibers->setEnabled(false);
         m_Controls->ddAvailableColorcodings->setEnabled(false);
         m_Controls->buttonExtractFibers->setEnabled(false);
         m_Controls->button_FAMap->setEnabled(true);
 
         m_Controls->buttonSMFibers->setEnabled(false);//not yet implemented
         m_Controls->buttonVtkDecimatePro->setEnabled(false);//not yet implemented
         m_Controls->buttonVtkSmoothPD->setEnabled(false);//not yet implemented
         m_Controls->buttonGenerateTubes->setEnabled(false);//not yet implemented
 
 
         connect( m_Controls->buttonGenerateFibers, SIGNAL(clicked()), this, SLOT(DoGenerateFibers()) );
         connect( m_Controls->buttonGenerateFiberIds, SIGNAL(clicked()), this, SLOT(DoGenerateFiberIDs()) );
         connect( m_Controls->button_FAMapExecute, SIGNAL(clicked()), this, SLOT(DoSetFAValues()) );
         connect( m_Controls->button_FAMap, SIGNAL(clicked()), this, SLOT(DoSetFAMap()) );
         connect( m_Controls->buttonExtractFibers, SIGNAL(clicked()), this, SLOT(DoExtractFibers()) );
         connect( m_Controls->radioButton_directionRandom, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionX, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionY, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionZ, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->toolBox, SIGNAL(currentChanged ( int ) ), this, SLOT(SelectionChangedToolBox(int)) );
 
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( ActionDrawEllipseTriggered() ) );
         connect( m_Controls->buttonColorFibers, SIGNAL(clicked()), this, SLOT(DoColorFibers()) );
         //        connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
         connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
 
         connect( m_Controls->checkBoxMonitorFiberThreads, SIGNAL(stateChanged(int)), this, SLOT(DoMonitorFiberThreads(int)) );
 
 
 
     }
 
     //  Checkpoint for fiber ORIENTATION
     if ( m_DirectionRadios.empty() )
     {
         m_DirectionRadios.insert(0, m_Controls->radioButton_directionRandom);
         m_DirectionRadios.insert(1, m_Controls->radioButton_directionX);
         m_DirectionRadios.insert(2, m_Controls->radioButton_directionY);
         m_DirectionRadios.insert(3, m_Controls->radioButton_directionZ);
     }
 
     // set GUI elements of FiberGenerator to according configuration
     DoUpdateGenerateFibersWidget();
 
 
 }
 /* THIS METHOD UPDATES ALL GUI ELEMENTS OF QGroupBox DEPENDING ON CURRENTLY SELECTED
  * RADIO BUTTONS
  */
 void QmitkFiberBundleDeveloperView::DoUpdateGenerateFibersWidget()
 {
     //get selected radioButton
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         // disable radiobuttons
         if (m_Controls->boxFiberMinLength->isEnabled())
             m_Controls->boxFiberMinLength->setEnabled(false);
 
         if (m_Controls->labelFiberMinLength->isEnabled())
             m_Controls->labelFiberMinLength->setEnabled(false);
 
         if (m_Controls->boxFiberMaxLength->isEnabled())
             m_Controls->boxFiberMaxLength->setEnabled(false);
 
         if (m_Controls->labelFiberMaxLength->isEnabled())
             m_Controls->labelFiberMaxLength->setEnabled(false);
 
         //enable radiobuttons
         if (!m_Controls->labelFibersTotal->isEnabled())
             m_Controls->labelFibersTotal->setEnabled(true);
 
         if (!m_Controls->boxFiberNumbers->isEnabled())
             m_Controls->boxFiberNumbers->setEnabled(true);
 
         if (!m_Controls->labelDistrRadius->isEnabled())
             m_Controls->labelDistrRadius->setEnabled(true);
 
         if (!m_Controls->boxDistributionRadius->isEnabled())
             m_Controls->boxDistributionRadius->setEnabled(true);
 
 
     } else {
         // disable radiobuttons
         if (m_Controls->labelDistrRadius->isEnabled())
             m_Controls->labelDistrRadius->setEnabled(false);
 
         if (m_Controls->boxDistributionRadius->isEnabled())
             m_Controls->boxDistributionRadius->setEnabled(false);
 
 
         //enable radiobuttons
         if (!m_Controls->labelFibersTotal->isEnabled())
             m_Controls->labelFibersTotal->setEnabled(true);
 
         if (!m_Controls->boxFiberNumbers->isEnabled())
             m_Controls->boxFiberNumbers->setEnabled(true);
 
         if (!m_Controls->boxFiberMinLength->isEnabled())
             m_Controls->boxFiberMinLength->setEnabled(true);
 
         if (!m_Controls->labelFiberMinLength->isEnabled())
             m_Controls->labelFiberMinLength->setEnabled(true);
 
         if (!m_Controls->boxFiberMaxLength->isEnabled())
             m_Controls->boxFiberMaxLength->setEnabled(true);
 
         if (!m_Controls->labelFiberMaxLength->isEnabled())
             m_Controls->labelFiberMaxLength->setEnabled(true);
 
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::DoGenerateFibers()
 {
 
     // GET SELECTED FIBER DIRECTION
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     //  vtkPolyData* output; // FiberPD stores the generated PolyData... going to be generated in thread
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         //    build polydata with random lines and fibers
         //    output =
         GenerateVtkFibersRandom();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_X ) {
         //    build polydata with XDirection fibers
         //output = GenerateVtkFibersDirectionX();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Y ) {
         //    build polydata with YDirection fibers
         // output = GenerateVtkFibersDirectionY();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Z ) {
         //    build polydata with ZDirection fibers
         //  output = GenerateVtkFibersDirectionZ();
 
     }
 
 
 }
 
 void QmitkFiberBundleDeveloperView::DoExtractFibers()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateExtractFibersTimer()) );
 
     struct Package4WorkingThread ItemPackageForExtractor;
     ItemPackageForExtractor.st_FBX = m_FiberBundleX;
     ItemPackageForExtractor.st_Controls = m_Controls;
     ItemPackageForExtractor.st_FancyGUITimer1 = localTimer;
     ItemPackageForExtractor.st_host = this; //needed to access method "PutFibersToDataStorage()"
     ItemPackageForExtractor.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
     ItemPackageForExtractor.st_PlanarFigure = m_PlanarFigure;
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         ItemPackageForExtractor.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberExtractor = new QmitkFiberExtractorWorker(m_hostThread, ItemPackageForExtractor);
     m_FiberExtractor->moveToThread(m_hostThread);
 
     //connections
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberExtraction() ));
     connect(m_hostThread, SIGNAL(started()), m_FiberExtractor, SLOT( run() ));
     connect(m_hostThread, SIGNAL(finished()), this, SLOT( AfterThread_FiberExtraction() ));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT( AfterThread_FiberExtraction() ));
 
     m_hostThread->start(QThread::HighestPriority) ;
 }
 
 void QmitkFiberBundleDeveloperView::UpdateExtractFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric! shall be done in beforeThreadstarted()
     QString crntValue = m_Controls->infoTimerExtractFibers->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerExtractFibers->setText(QString::number(++tmpVal));
     m_Controls->infoTimerExtractFibers->update();
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberExtraction()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         //m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberExtraction()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     //    disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
 
     //    m_FiberExtractor->disconnect();
     delete m_FiberExtractor;
 
     m_FiberBundleNode->Modified();
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkFiberBundleDeveloperView::PutFibersToDataStorage( vtkSmartPointer<vtkPolyData> threadOutput)
 {
 
     MITK_INFO << "lines: " << threadOutput->GetNumberOfLines() << "pnts: " << threadOutput->GetNumberOfPoints();
     //qthread mutex lock
     mitk::FiberBundleX::Pointer FB = mitk::FiberBundleX::New(threadOutput);
     mitk::DataNode::Pointer FBNode;
     FBNode = mitk::DataNode::New();
     FBNode->SetName("FiberBundleX");
     FBNode->SetData(FB);
     FBNode->SetVisibility(true);
     FBNode->SetOpacity(1.0);
 
     GetDataStorage()->Add(FBNode);
     FBNode->Modified();
 
     const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
     if (tsgeo == NULL) {
         /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
         // get all nodes that have not set "includeInBoundingBox" to false
         mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
                                                                                                             , mitk::BoolProperty::New(false)));
         mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
         // calculate bounding geometry of these nodes
-        mitk::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
+        mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
         // initialize the views to the bounding geometry
         mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
     } else {
 
         GetDataStorage()->Modified();
         m_MultiWidget->RequestUpdate(); //necessary??
     }
 
     //qthread mutex unlock
 }
 
 void QmitkFiberBundleDeveloperView::PutFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name)
 {
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
 
 
 
     std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
     for(unsigned int i = 0; i < selectedNodes.size(); i++)
     {
         selectedNodes[i]->SetSelected(false);
     }
 
     newNode->SetSelected(true);
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,0.0,0.0));
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true));
 
     newNode->AddProperty( "selected", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(false) );
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
 
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(3.0) );
     newNode->AddProperty( "planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
     newNode->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(0.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0)  );
     newNode->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(2.0));
 
     // figure drawn on the topmost layer / image
     this->GetDataStorage()->Add(newNode);
 }
 
 /*
  * Generate polydata of random fibers
  */
 void QmitkFiberBundleDeveloperView::GenerateVtkFibersRandom()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateGenerateRandomFibersTimer()) );
 
     struct Package4WorkingThread ItemPackageForRandomGenerator;
     ItemPackageForRandomGenerator.st_FBX = m_FiberBundleX;
     ItemPackageForRandomGenerator.st_Controls = m_Controls;
     ItemPackageForRandomGenerator.st_FancyGUITimer1 = localTimer;
     ItemPackageForRandomGenerator.st_host = this; //needed to access method "PutFibersToDataStorage()"
     ItemPackageForRandomGenerator.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         ItemPackageForRandomGenerator.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_GeneratorFibersRandom = new QmitkFiberGenerateRandomWorker(m_hostThread, ItemPackageForRandomGenerator);
     m_GeneratorFibersRandom->moveToThread(m_hostThread);
 
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_GenerateFibersRandom()) );
     connect(m_hostThread, SIGNAL(started()), m_GeneratorFibersRandom, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_GenerateFibersRandom()) );
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_GenerateFibersRandom()) );
 
     m_hostThread->start(QThread::LowestPriority);
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateColorFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerColorCoding->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerColorCoding->setText(QString::number(++tmpVal));
     m_Controls->infoTimerColorCoding->update();
 }
 
 void QmitkFiberBundleDeveloperView::UpdateGenerateRandomFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerGenerateFiberBundle->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerGenerateFiberBundle->setText(QString::number(++tmpVal));
     m_Controls->infoTimerGenerateFiberBundle->update();
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateSetFAValuesTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerSetFA->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerSetFA->setText(QString::number(++tmpVal));
     m_Controls->infoTimerSetFA->update();
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_GenerateFibersRandom()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         //m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_GenerateFibersRandom()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     //    disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     delete m_GeneratorFibersRandom;
 
 
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionX()
 {
     int numOfFibers = m_Controls->boxFiberNumbers->value();
     vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
 
     //insert Origin point, this point has index 0 in point array
     double originX = 0.0;
     double originY = 0.0;
     double originZ = 0.0;
 
     //after each iteration the origin of the new fiber increases
     //here you set which direction is affected.
     double increaseX = 0.0;
     double increaseY = 1.0;
     double increaseZ = 0.0;
 
 
     //walk along X axis
     //length of fibers increases in each iteration
     for (int i=0; i<numOfFibers; ++i) {
 
         vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
         newFiber->GetPointIds()->SetNumberOfIds(i+2);
 
         //create starting point and add it to pointset
         points->InsertNextPoint(originX + (double)i * increaseX , originY + (double)i * increaseY, originZ + (double)i * increaseZ);
 
         //add starting point to fiber
         newFiber->GetPointIds()->SetId(0,points->GetNumberOfPoints()-1);
 
         //insert remaining points for fiber
         for (int pj=0; pj<=i ; ++pj)
         { //generate next point on X axis
             points->InsertNextPoint( originX + (double)pj+1 , originY + (double)i * increaseY, originZ + (double)i * increaseZ );
             newFiber->GetPointIds()->SetId(pj+1,points->GetNumberOfPoints()-1);
         }
 
         linesCell->InsertNextCell(newFiber);
     }
 
     vtkSmartPointer<vtkPolyData> PDX = vtkSmartPointer<vtkPolyData>::New();
     PDX->SetPoints(points);
     PDX->SetLines(linesCell);
     return PDX;
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionY()
 {
     vtkSmartPointer<vtkPolyData> PDY = vtkSmartPointer<vtkPolyData>::New();
     //todo
 
 
 
     return PDY;
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionZ()
 {
     vtkSmartPointer<vtkPolyData> PDZ = vtkSmartPointer<vtkPolyData>::New();
     //todo
 
 
 
     return PDZ;
 }
 
 void QmitkFiberBundleDeveloperView::DoSetFAValues()
 {
 
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateSetFAValuesTimer() ) );
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread ItemPackageToSetFAMap;
     ItemPackageToSetFAMap.st_FBX = m_FiberBundleX;
     ItemPackageToSetFAMap.st_FancyGUITimer1 = localTimer;
     ItemPackageToSetFAMap.st_PassedDataNode = m_FANode;
     ItemPackageToSetFAMap.st_Controls = m_Controls;
 
     if (m_fiberMonitorIsOn)
         ItemPackageToSetFAMap.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberFeederFASlave = new QmitkFiberFeederFAWorker(m_hostThread, ItemPackageToSetFAMap);
     m_FiberFeederFASlave->moveToThread(m_hostThread);
 
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberSetFA()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberFeederFASlave, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberSetFA()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberSetFA()));
     m_hostThread->start(QThread::LowestPriority);
 }
 
 void QmitkFiberBundleDeveloperView::DoSetFAMap()
 {
     std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
     if (nodes.empty())
     {
         m_Controls->lineEdit_FAMap->setText("N/A");
         return;
     }
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
          it != nodes.end();
          ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
         {
             // this node is what we want
             m_FANode = node;
             m_Controls->lineEdit_FAMap->setText(node->GetName().c_str());
             return;
         }
     }
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberSetFA()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberSetFA()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     //update renderer
     m_FiberBundleNode->Modified();
     m_MultiWidget->ForceImmediateUpdate();
 
     //update QComboBox(dropDown menu) in view of available ColorCodings
     this->DoGatherColorCodings();
 
     delete m_FiberFeederFASlave;
 }
 
 void QmitkFiberBundleDeveloperView::DoColorFibers()
 {
     //
     MITK_INFO << "call fibercoloring in fiberBundleX";
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateColorFibersTimer() ) );
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread ItemPackageForFiberColoring;
     ItemPackageForFiberColoring.st_FBX = m_FiberBundleX;
     ItemPackageForFiberColoring.st_PassedDataNode = m_FiberBundleNode;
     ItemPackageForFiberColoring.st_FancyGUITimer1 = localTimer;
     ItemPackageForFiberColoring.st_Controls = m_Controls; //needed to catch up some selections and set options in GUI
 
     if (m_fiberMonitorIsOn)
         ItemPackageForFiberColoring.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberColoringSlave = new QmitkFiberColoringWorker(m_hostThread, ItemPackageForFiberColoring);
     m_FiberColoringSlave->moveToThread(m_hostThread);
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberColorCoding()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberColoringSlave, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberColorCoding()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberColorCoding()));
     m_hostThread->start(QThread::LowestPriority);
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberColorCoding()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
     }
 }
 
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberColorCoding()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     //update renderer
     m_FiberBundleNode->Modified();
     m_MultiWidget->ForceImmediateUpdate();
 
 
     //update QComboBox(dropDown menu) in view of available ColorCodings
     this->DoGatherColorCodings();
 
     delete m_FiberColoringSlave;
 }
 
 
 void QmitkFiberBundleDeveloperView::DoGatherColorCodings()
 {
     QStringList fbxColorCodings = m_FiberBundleX->GetAvailableColorCodings();
 
     //update dropDown Menu
     //remove all items from menu
     m_suppressSignal = true;
     int ddItems = m_Controls->ddAvailableColorcodings->count();
     for(int i=ddItems-1; i>=0; i--)
     {   //note, after each item remove, index in QComboBox is updated. sending signal: index changed
         m_Controls->ddAvailableColorcodings->removeItem(i);
     }
     //fill new data into menu
     m_Controls->ddAvailableColorcodings->addItems(fbxColorCodings);
     m_Controls->ddAvailableColorcodings->addItem(m_FiberBundleX->COLORCODING_CUSTOM);
 
     //highlight current colorcoding
     QString cc = m_FiberBundleX->GetCurrentColorCoding();
     MITK_INFO << cc.toStdString().c_str() << " is at idx: " << m_Controls->ddAvailableColorcodings->findText(cc);
     m_Controls->ddAvailableColorcodings->setCurrentIndex( m_Controls->ddAvailableColorcodings->findText(cc) );
     m_Controls->ddAvailableColorcodings->update();
     m_suppressSignal = false;
 }
 
 
 void QmitkFiberBundleDeveloperView::SetCurrentColorCoding(int idx)
 {
     if(!m_suppressSignal){
         QString selectedColorCoding = m_Controls->ddAvailableColorcodings->itemText(idx);
         m_FiberBundleX->SetColorCoding(selectedColorCoding.toStdString().c_str() ); //QString to char
         // update rendering
         m_FiberBundleNode->Modified();
         m_MultiWidget->ForceImmediateUpdate();
     }
 }
 
 /* === OutSourcedMethod: THIS METHOD GENERATES ESSENTIAL GEOMETRY PARAMETERS FOR THE MITK FRAMEWORK ===
  * WITHOUT, the rendering mechanism will ignore objects without valid Geometry
  * for each object, MITK requires: ORIGIN, SPACING, TRANSFORM MATRIX, BOUNDING-BOX */
 mitk::Geometry3D::Pointer QmitkFiberBundleDeveloperView::GenerateStandardGeometryForMITK()
 {
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
 
     // generate origin
     mitk::Point3D origin;
     origin[0] = 0;
     origin[1] = 0;
     origin[2] = 0;
     geometry->SetOrigin(origin);
 
     // generate spacing
     float spacing[3] = {1,1,1};
     geometry->SetSpacing(spacing);
 
 
     // generate identity transform-matrix
     vtkSmartPointer<vtkMatrix4x4> m = vtkSmartPointer<vtkMatrix4x4>::New();
     geometry->SetIndexToWorldTransformByVtkMatrix(m);
 
     // generate boundingbox
     // for an usable bounding-box use gui parameters to estimate the boundingbox
     float bounds[] = {500, 500, 500, -500, -500, -500};
 
     // GET SELECTED FIBER DIRECTION
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         // use information about distribution parameter to calculate bounding box
         int distrRadius = m_Controls->boxDistributionRadius->value();
         bounds[0] = distrRadius;
         bounds[1] = distrRadius;
         bounds[2] = distrRadius;
         bounds[3] = -distrRadius;
         bounds[4] = -distrRadius;
         bounds[5] = -distrRadius;
 
     } else {
         // so far only X,Y,Z directions are available
         MITK_INFO << "_______GEOMETRY ISSUE_____\n***BoundingBox for X, Y, Z fiber directions are not optimized yet!***";
 
         int maxFibLength = m_Controls->boxFiberMaxLength->value();
         bounds[0] = maxFibLength;
         bounds[1] = maxFibLength;
         bounds[2] = maxFibLength;
         bounds[3] = -maxFibLength;
         bounds[4] = -maxFibLength;
         bounds[5] = -maxFibLength;
     }
 
     geometry->SetFloatBounds(bounds);
     geometry->SetImageGeometry(true); //??
 
     return geometry;
 
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateFiberIDTimer()
 {
     //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
     QString crntValue = m_Controls->infoTimerGenerateFiberIds->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerGenerateFiberIds->setText(QString::number(++tmpVal));
     m_Controls->infoTimerGenerateFiberIds->update();
 
 }
 
 /* Initialie ID dataset in FiberBundleX */
 void QmitkFiberBundleDeveloperView::DoGenerateFiberIDs()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateFiberIDTimer()) );
 
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread FiberIdPackage;
     FiberIdPackage.st_FBX = m_FiberBundleX;
     FiberIdPackage.st_FancyGUITimer1 = localTimer;
     FiberIdPackage.st_Controls = m_Controls;
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         FiberIdPackage.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     // THREAD CONFIGURATION
     m_FiberIDGenerator = new QmitkFiberIDWorker(m_hostThread, FiberIdPackage);
     m_FiberIDGenerator->moveToThread(m_hostThread);
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_IdGenerate()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberIDGenerator, SLOT(run()));
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_IdGenerate()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_IdGenerate()));
     m_hostThread->start(QThread::LowestPriority);
 
 
 
     // m_Controls->infoTimerGenerateFiberIds->setText(QString::number(clock.GetTotal()));
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_IdGenerate()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_IdGenerate()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     delete m_FiberIDGenerator;
 
 }
 
 
 void  QmitkFiberBundleDeveloperView::ResetFiberInfoWidget()
 {
     if (m_Controls->infoAnalyseNumOfFibers->isEnabled()) {
         m_Controls->infoAnalyseNumOfFibers->setText("-");
         m_Controls->infoAnalyseNumOfPoints->setText("-");
         m_Controls->infoAnalyseNumOfFibers->setEnabled(false);
     }
 }
 
 void  QmitkFiberBundleDeveloperView::FeedFiberInfoWidget()
 {
     if (!m_Controls->infoAnalyseNumOfFibers->isEnabled())
         m_Controls->infoAnalyseNumOfFibers->setEnabled(true);
 
     QString numOfFibers;
     numOfFibers.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfLines() );
     QString numOfPoints;
     numOfPoints.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfPoints() );
 
     m_Controls->infoAnalyseNumOfFibers->setText( numOfFibers );
     m_Controls->infoAnalyseNumOfPoints->setText( numOfPoints );
 }
 
 void QmitkFiberBundleDeveloperView::SelectionChangedToolBox(int idx)
 {
     // show/reset items of selected toolbox page FiberInfo
     if (m_Controls->page_FiberInfo->isVisible())
     {
         if (m_FiberBundleX != NULL) {
             FeedFiberInfoWidget();
 
         } else {
             //if infolables are disabled: return
             //else set info back to - and set label and info to disabled
             ResetFiberInfoWidget();
         }
     }
 
     // show/reset items of selected toolbox page FiberProcessing
     if (m_Controls->page_FiberProcessing->isVisible())
     {
         if (m_FiberBundleX.IsNotNull() && m_PlanarFigure.IsNotNull() )
         {
             //show fiber extraction button
             m_Controls->buttonExtractFibers->setEnabled(true);
 
         } else {
             m_Controls->buttonExtractFibers->setEnabled(false);
         }
 
         if (m_FiberBundleX.IsNotNull())
         {
             //show button colorCoding
             m_Controls->buttonColorFibers->setEnabled(true);
             m_Controls->ddAvailableColorcodings->setEnabled(true);
             m_Controls->buttonGenerateFiberIds->setEnabled(true);
 
             //       m_Controls->buttonSMFibers->setEnabled(true);
             //       m_Controls->buttonVtkDecimatePro->setEnabled(true);
             //       m_Controls->buttonVtkSmoothPD->setEnabled(true);
             //       m_Controls->buttonGenerateTubes->setEnabled(true);
 
         } else {
             m_Controls->buttonColorFibers->setEnabled(false);
             m_Controls->ddAvailableColorcodings->setEnabled(false);
             m_Controls->buttonGenerateFiberIds->setEnabled(false);
             m_Controls->buttonSMFibers->setEnabled(false);
             m_Controls->buttonVtkDecimatePro->setEnabled(false);
             m_Controls->buttonVtkSmoothPD->setEnabled(false);
             m_Controls->buttonGenerateTubes->setEnabled(true);
 
         }
 
 
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::FBXDependendGUIElementsConfigurator()
 {
     // ==== FIBER PROCESSING ELEMENTS and ALL ELEMENTS WHICH NEED A FBX DATANODE======
     //  m_Controls->buttonGenerateFiberIds->setEnabled(isVisible); moved to selectionChangedToolBox
 
     SelectionChangedToolBox(-1); //set gui elements with respect to active tab, widget, etc. -1 has no effect
 
 }
 
 
 void QmitkFiberBundleDeveloperView::DoMonitorFiberThreads(int checkStatus)
 {
     //check if in datanode exists already a node of type mitkFiberBundleXThreadMonitor
     //if not then put node to datastorage
 
     //if checkStatus is 1 then start qtimer using fading in starting text in datanode
     //if checkStatus is 0 then fade out dataNode using qtimer
 
     if (checkStatus)
     {
         m_fiberMonitorIsOn = true;
         // Generate Node hosting thread information
         mitk::FiberBundleXThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleXThreadMonitor::New();
         FBXThreadMonitor->SetGeometry(this->GenerateStandardGeometryForMITK());
 
         m_MonitorNode = mitk::DataNode::New();
         m_MonitorNode->SetName("FBX_threadMonitor");
         m_MonitorNode->SetData(FBXThreadMonitor);
         m_MonitorNode->SetVisibility(true);
         m_MonitorNode->SetOpacity(1.0);
 
         GetDataStorage()->Add(m_MonitorNode);
 
         //following code is needed for rendering text in mitk! without geometry nothing is rendered
         const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
         if (tsgeo == NULL) {
             /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
             // get all nodes that have not set "includeInBoundingBox" to false
             mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New( "includeInBoundingBox"
                                                                                                                  , mitk::BoolProperty::New(false)));
             mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
             // calculate bounding geometry of these nodes
-            mitk::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
+            mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
             // initialize the views to the bounding geometry
             mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
         } else {
 
             GetDataStorage()->Modified();
             m_MultiWidget->RequestUpdate(); //necessary??
         }
         //__GEOMETRY FOR THREADMONITOR GENERATED
 
         /* ====== initialize thread for managing fiberThread information ========= */
         m_monitorThread = new QThread;
         // the package needs datastorage, MonitorDatanode, standardmultiwidget,
         struct Package4WorkingThread ItemPackageForThreadMonitor;
         ItemPackageForThreadMonitor.st_DataStorage = GetDataStorage();
         ItemPackageForThreadMonitor.st_ThreadMonitorDataNode = m_MonitorNode;
         ItemPackageForThreadMonitor.st_MultiWidget = m_MultiWidget;
         ItemPackageForThreadMonitor.st_FBX_Monitor = FBXThreadMonitor;
 
         m_fiberThreadMonitorWorker = new QmitkFiberThreadMonitorWorker(m_monitorThread, ItemPackageForThreadMonitor);
 
         m_fiberThreadMonitorWorker->moveToThread(m_monitorThread);
         connect ( m_monitorThread, SIGNAL( started() ), m_fiberThreadMonitorWorker, SLOT( run() ) );
         m_monitorThread->start(QThread::LowestPriority);
         m_fiberThreadMonitorWorker->initializeMonitor();//do some init animation ;-)
 
 
     } else {
         m_fiberMonitorIsOn = false;
 
         m_monitorThread->quit();
         //think about outsourcing following lines to quit / terminate slot of thread
         GetDataStorage()->Remove(m_MonitorNode);
         GetDataStorage()->Modified();
         m_MultiWidget->RequestUpdate(); //necessary??
     }
 
 
 
 }
 
 
 
 void QmitkFiberBundleDeveloperView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkFiberBundleDeveloperView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
  implement SelectionService Listener explicitly */
 void QmitkFiberBundleDeveloperView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
 
     if (nodes.empty())
         return;
     /* ==== reset everyhing related to FiberBundleX ======
    * - variable m_FiberBundleX
    * - visualization of analysed fiberbundle
    */
     m_FiberBundleNode = NULL;
     m_FiberBundleX = NULL; //reset pointer, so that member does not point to depricated locations
     m_PlanarFigure = NULL;
     ResetFiberInfoWidget();
 
 
     //timer reset only when no thread is in progress
     if (!m_threadInProgress) {
         m_Controls->infoTimerGenerateFiberIds->setText("-"); //set GUI representation of timer to -
         m_Controls->infoTimerGenerateFiberBundle->setText( "-" );
         m_Controls->infoTimerColorCoding->setText( "-" );
     }
     //====================================================
 
 
 
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         /* CHECKPOINT: FIBERBUNDLE*/
         if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_FiberBundleNode = node;
             m_FiberBundleX = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
             if (m_FiberBundleX.IsNull()){
                 MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundleX to FiberBundleDeveloper-plugin \n";
                 m_FiberBundleNode = NULL;
             }
             // ==== FIBERBUNDLE_INFO ELEMENTS ====
             if ( m_Controls->page_FiberInfo->isVisible() )
                 FeedFiberInfoWidget();
 
             // enable FiberBundleX related Gui Elements, such as buttons etc.
             this->FBXDependendGUIElementsConfigurator();
             this->DoGatherColorCodings();
 
         }
         /* CHECKPOINT: PLANARFIGURE */
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarFigure*>(node->GetData()) )
         {
             m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
             MITK_INFO << "PF selected";
 
             if (m_PlanarFigure.IsNull())
                 MITK_INFO << "========ATTENTION=========\n unable to load selected Planarfigure to FiberBundleDeveloper-plugin \n";
 
         }
 
     }
     //update gui elements depending on given nodes
 
     FBXDependendGUIElementsConfigurator(); //every gui element which needs a FBX for processing is disabled
 }
 
 
 void QmitkFiberBundleDeveloperView::ActionDrawEllipseTriggered()
 {
     //    bool checked = m_Controls->m_CircleButton->isChecked();
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     this->PutFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 
     MITK_INFO << "PlanarCircle created ...";
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
     mitk::PlanarFigure* figureP = 0;
 
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figureP)
         {
           figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
           if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::Activated()
 {
 
     MITK_INFO << "FB DevelopersV ACTIVATED()";
 
 
 }
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
old mode 100755
new mode 100644
index b126cdd1c0..45dbec12dc
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2026 +1,2026 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberfoxView.h"
 
 // MITK
 #include <mitkImage.h>
 #include <mitkDiffusionImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkDataStorage.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <QFileDialog>
 #include <QMessageBox>
 #include "usModuleRegistry.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
 
 QmitkFiberfoxView::QmitkFiberfoxView()
     : QmitkAbstractView()
     , m_Controls( 0 )
     , m_SelectedImage( NULL )
 {
 
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
 
 }
 
 void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberfoxViewControls;
         m_Controls->setupUi( parent );
 
         m_Controls->m_StickWidget1->setVisible(true);
         m_Controls->m_StickWidget2->setVisible(false);
         m_Controls->m_ZeppelinWidget1->setVisible(false);
         m_Controls->m_ZeppelinWidget2->setVisible(false);
         m_Controls->m_TensorWidget1->setVisible(false);
         m_Controls->m_TensorWidget2->setVisible(false);
 
         m_Controls->m_BallWidget1->setVisible(true);
         m_Controls->m_BallWidget2->setVisible(false);
         m_Controls->m_AstrosticksWidget1->setVisible(false);
         m_Controls->m_AstrosticksWidget2->setVisible(false);
         m_Controls->m_DotWidget1->setVisible(false);
         m_Controls->m_DotWidget2->setVisible(false);
 
         m_Controls->m_Comp4FractionFrame->setVisible(false);
         m_Controls->m_DiffusionPropsMessage->setVisible(false);
         m_Controls->m_GeometryMessage->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_VarianceBox->setVisible(false);
         m_Controls->m_GibbsRingingFrame->setVisible(false);
         m_Controls->m_NoiseFrame->setVisible(false);
         m_Controls->m_GhostFrame->setVisible(false);
         m_Controls->m_DistortionsFrame->setVisible(false);
         m_Controls->m_EddyFrame->setVisible(false);
         m_Controls->m_SpikeFrame->setVisible(false);
 
         m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_FrequencyMapBox->SetPredicate(finalPredicate);
 
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
         connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
         connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
         connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
         connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
         connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
         connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
         connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
         connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
         connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
         connect((QObject*) m_Controls->m_AddGibbsRinging, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGibbsRinging(int)));
         connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
         connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
         connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
         connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
         connect((QObject*) m_Controls->m_AddSpikes, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddSpikes(int)));
 
         connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
         connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
         connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
         connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
 
         connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
 
         connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
         connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
 
         connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
         connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
     }
 }
 
 void QmitkFiberfoxView::UpdateImageParameters()
 {
     m_ImageGenParameters.artifactList.clear();
     m_ImageGenParameters.nonFiberModelList.clear();
     m_ImageGenParameters.fiberModelList.clear();
     m_ImageGenParameters.signalModelString = "";
     m_ImageGenParameters.artifactModelString = "";
     m_ImageGenParameters.resultNode = mitk::DataNode::New();
     m_ImageGenParameters.tissueMaskImage = NULL;
     m_ImageGenParameters.frequencyMap = NULL;
     m_ImageGenParameters.gradientDirections.clear();
     m_ImageGenParameters.spikes = 0;
     m_ImageGenParameters.spikeAmplitude = 1;
 
     if (m_SelectedDWI.IsNotNull())  // use parameters of selected DWI
     {
         mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedDWI->GetData());
         m_ImageGenParameters.imageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
         m_ImageGenParameters.imageSpacing = dwi->GetVectorImage()->GetSpacing();
         m_ImageGenParameters.imageOrigin = dwi->GetVectorImage()->GetOrigin();
         m_ImageGenParameters.imageDirection = dwi->GetVectorImage()->GetDirection();
         m_ImageGenParameters.b_value = dwi->GetB_Value();
         mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = dwi->GetDirections();
 
         m_ImageGenParameters.numGradients = 0;
         for (int i=0; i<dirs->Size(); i++)
         {
             DiffusionSignalModel<double>::GradientType g;
             g[0] = dirs->at(i)[0];
             g[1] = dirs->at(i)[1];
             g[2] = dirs->at(i)[2];
             m_ImageGenParameters.gradientDirections.push_back(g);
             if (dirs->at(i).magnitude()>0.0001)
                 m_ImageGenParameters.numGradients++;
         }
     }
     else if (m_SelectedImage.IsNotNull())   // use geometry of selected image
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImage->GetData());
         itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
         CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
         m_ImageGenParameters.imageRegion = itkImg->GetLargestPossibleRegion();
         m_ImageGenParameters.imageSpacing = itkImg->GetSpacing();
         m_ImageGenParameters.imageOrigin = itkImg->GetOrigin();
         m_ImageGenParameters.imageDirection = itkImg->GetDirection();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
     else    // use GUI parameters
     {
         m_ImageGenParameters.imageRegion.SetSize(0, m_Controls->m_SizeX->value());
         m_ImageGenParameters.imageRegion.SetSize(1, m_Controls->m_SizeY->value());
         m_ImageGenParameters.imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
         m_ImageGenParameters.imageSpacing[0] = m_Controls->m_SpacingX->value();
         m_ImageGenParameters.imageSpacing[1] = m_Controls->m_SpacingY->value();
         m_ImageGenParameters.imageSpacing[2] = m_Controls->m_SpacingZ->value();
         m_ImageGenParameters.imageOrigin[0] = m_ImageGenParameters.imageSpacing[0]/2;
         m_ImageGenParameters.imageOrigin[1] = m_ImageGenParameters.imageSpacing[1]/2;
         m_ImageGenParameters.imageOrigin[2] = m_ImageGenParameters.imageSpacing[2]/2;
         m_ImageGenParameters.imageDirection.SetIdentity();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());;
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
 
     // signal relaxation
     m_ImageGenParameters.doSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
     if (m_ImageGenParameters.doSimulateRelaxation)
         m_ImageGenParameters.artifactModelString += "_RELAX";
 
     // N/2 ghosts
     if (m_Controls->m_AddGhosts->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_GHOST";
         m_ImageGenParameters.kspaceLineOffset = m_Controls->m_kOffsetBox->value();
     }
     else
         m_ImageGenParameters.kspaceLineOffset = 0;
 
     m_ImageGenParameters.tLine = m_Controls->m_LineReadoutTimeBox->value();
     m_ImageGenParameters.tInhom = m_Controls->m_T2starBox->value();
     m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
     m_ImageGenParameters.repetitions = m_Controls->m_RepetitionsBox->value();
     m_ImageGenParameters.doDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
     m_ImageGenParameters.interpolationShrink = m_Controls->m_InterpolationShrink->value();
     m_ImageGenParameters.axonRadius = m_Controls->m_FiberRadius->value();
     m_ImageGenParameters.signalScale = m_Controls->m_SignalScaleBox->value();
 
     if (m_Controls->m_AddSpikes->isChecked())
     {
         m_ImageGenParameters.spikes = m_Controls->m_SpikeNumBox->value();
         m_ImageGenParameters.spikeAmplitude = m_Controls->m_SpikeScaleBox->value();
         m_ImageGenParameters.artifactModelString += "_SPIKES";
     }
 
     // adjust echo time if needed
     if ( m_ImageGenParameters.tEcho < m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine )
     {
         this->m_Controls->m_TEbox->setValue( m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine );
         m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
         QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(m_ImageGenParameters.tEcho)+" ms");
     }
 
     // check tissue mask
     if (m_TissueMask.IsNotNull())
     {
         m_ImageGenParameters.tissueMaskImage = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(m_TissueMask, m_ImageGenParameters.tissueMaskImage);
     }
 
     // rician noise
     if (m_Controls->m_AddNoise->isChecked())
     {
         double noiseVariance = m_Controls->m_NoiseLevel->value();
         m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(noiseVariance);
         m_ImageGenParameters.artifactModelString += "_NOISE";
         m_ImageGenParameters.artifactModelString += QString::number(noiseVariance);
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
     else
         m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(0);
 
     // gibbs ringing
     m_ImageGenParameters.upsampling = 1;
     if (m_Controls->m_AddGibbsRinging->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_RINGING";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Ringing-Upsampling", DoubleProperty::New(m_Controls->m_ImageUpsamplingBox->value()));
         m_ImageGenParameters.upsampling = m_Controls->m_ImageUpsamplingBox->value();
     }
 
     // adjusting line readout time to the adapted image size needed for the DFT
     int y = m_ImageGenParameters.imageRegion.GetSize(1);
     if ( y%2 == 1 )
         y += 1;
     if ( y>m_ImageGenParameters.imageRegion.GetSize(1) )
         m_ImageGenParameters.tLine *= (double)m_ImageGenParameters.imageRegion.GetSize(1)/y;
 
     // add distortions
     if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
     {
         mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
         mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
         ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
         CastToItkImage< ItkDoubleImgType >(img, itkImg);
 
         if (m_ImageGenParameters.imageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
                 m_ImageGenParameters.imageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
                 m_ImageGenParameters.imageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
         {
             m_ImageGenParameters.frequencyMap = itkImg;
             m_ImageGenParameters.artifactModelString += "_DISTORTED";
         }
     }
 
     m_ImageGenParameters.doSimulateEddyCurrents = m_Controls->m_AddEddy->isChecked();
     m_ImageGenParameters.eddyStrength = 0;
     if (m_Controls->m_AddEddy->isChecked())
     {
         m_ImageGenParameters.eddyStrength = m_Controls->m_EddyGradientStrength->value();
         m_ImageGenParameters.artifactModelString += "_EDDY";
     }
 
     // signal models
     m_ImageGenParameters.comp3Weight = 1;
     m_ImageGenParameters.comp4Weight = 0;
     if (m_Controls->m_Compartment4Box->currentIndex()>0)
     {
         m_ImageGenParameters.comp4Weight = m_Controls->m_Comp4FractionBox->value();
         m_ImageGenParameters.comp3Weight -= m_ImageGenParameters.comp4Weight;
     }
 
     // compartment 1
     switch (m_Controls->m_Compartment1Box->currentIndex())
     {
     case 0:
         m_StickModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel1.SetDiffusivity(m_Controls->m_StickWidget1->GetD());
         m_StickModel1.SetT2(m_Controls->m_StickWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel1);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_StickModel1.GetT2()) );
         break;
     case 1:
         m_ZeppelinModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel1.SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
         m_ZeppelinModel1.SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel1);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     case 2:
         m_TensorModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel1.SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
         m_TensorModel1.SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
         m_TensorModel1.SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
         m_TensorModel1.SetT2(m_Controls->m_TensorWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel1);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     }
 
     // compartment 2
     switch (m_Controls->m_Compartment2Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_StickModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel2.SetDiffusivity(m_Controls->m_StickWidget2->GetD());
         m_StickModel2.SetT2(m_Controls->m_StickWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel2);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_StickModel2.GetT2()) );
         break;
     case 2:
         m_ZeppelinModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel2.SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
         m_ZeppelinModel2.SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel2);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     case 3:
         m_TensorModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel2.SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
         m_TensorModel2.SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
         m_TensorModel2.SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
         m_TensorModel2.SetT2(m_Controls->m_TensorWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel2);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     }
 
     // compartment 3
     switch (m_Controls->m_Compartment3Box->currentIndex())
     {
     case 0:
         m_BallModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel1.SetDiffusivity(m_Controls->m_BallWidget1->GetD());
         m_BallModel1.SetT2(m_Controls->m_BallWidget1->GetT2());
         m_BallModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel1);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_BallModel1.GetT2()) );
         break;
     case 1:
         m_AstrosticksModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel1.SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
         m_AstrosticksModel1.SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
         m_AstrosticksModel1.SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
         m_AstrosticksModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel1);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_AstrosticksModel1.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
         break;
     case 2:
         m_DotModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel1.SetT2(m_Controls->m_DotWidget1->GetT2());
         m_DotModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel1);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_DotModel1.GetT2()) );
         break;
     }
 
     // compartment 4
     switch (m_Controls->m_Compartment4Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_BallModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel2.SetDiffusivity(m_Controls->m_BallWidget2->GetD());
         m_BallModel2.SetT2(m_Controls->m_BallWidget2->GetT2());
         m_BallModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel2);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_BallModel2.GetT2()) );
         break;
     case 2:
         m_AstrosticksModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel2.SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
         m_AstrosticksModel2.SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
         m_AstrosticksModel2.SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
         m_AstrosticksModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel2);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_AstrosticksModel2.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
         break;
     case 3:
         m_DotModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel2.SetT2(m_Controls->m_DotWidget2->GetT2());
         m_DotModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel2);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_DotModel2.GetT2()) );
         break;
     }
 
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.InterpolationShrink", IntProperty::New(m_ImageGenParameters.interpolationShrink));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(m_ImageGenParameters.signalScale));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(m_ImageGenParameters.axonRadius));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Tinhom", IntProperty::New(m_ImageGenParameters.tInhom));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Repetitions", IntProperty::New(m_ImageGenParameters.repetitions));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(m_ImageGenParameters.b_value));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Model", StringProperty::New(m_ImageGenParameters.signalModelString.toStdString()));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.PureFiberVoxels", BoolProperty::New(m_ImageGenParameters.doDisablePartialVolume));
     m_ImageGenParameters.resultNode->AddProperty("binary", BoolProperty::New(false));
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
     UpdateImageParameters();
 
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 QDir::currentPath()+"/param.ffp",
                 tr("Fiberfox Parameters (*.ffp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".ffp"))
         filename += ".ffp";
 
     boost::property_tree::ptree parameters;
 
     // fiber generation parameters
     parameters.put("fiberfox.fibers.realtime", m_Controls->m_RealTimeFibers->isChecked());
     parameters.put("fiberfox.fibers.showadvanced", m_Controls->m_AdvancedOptionsBox->isChecked());
     parameters.put("fiberfox.fibers.distribution", m_Controls->m_DistributionBox->currentIndex());
     parameters.put("fiberfox.fibers.variance", m_Controls->m_VarianceBox->value());
     parameters.put("fiberfox.fibers.density", m_Controls->m_FiberDensityBox->value());
     parameters.put("fiberfox.fibers.spline.sampling", m_Controls->m_FiberSamplingBox->value());
     parameters.put("fiberfox.fibers.spline.tension", m_Controls->m_TensionBox->value());
     parameters.put("fiberfox.fibers.spline.continuity", m_Controls->m_ContinuityBox->value());
     parameters.put("fiberfox.fibers.spline.bias", m_Controls->m_BiasBox->value());
     parameters.put("fiberfox.fibers.constantradius", m_Controls->m_ConstantRadiusBox->isChecked());
     parameters.put("fiberfox.fibers.rotation.x", m_Controls->m_XrotBox->value());
     parameters.put("fiberfox.fibers.rotation.y", m_Controls->m_YrotBox->value());
     parameters.put("fiberfox.fibers.rotation.z", m_Controls->m_ZrotBox->value());
     parameters.put("fiberfox.fibers.translation.x", m_Controls->m_XtransBox->value());
     parameters.put("fiberfox.fibers.translation.y", m_Controls->m_YtransBox->value());
     parameters.put("fiberfox.fibers.translation.z", m_Controls->m_ZtransBox->value());
     parameters.put("fiberfox.fibers.scale.x", m_Controls->m_XscaleBox->value());
     parameters.put("fiberfox.fibers.scale.y", m_Controls->m_YscaleBox->value());
     parameters.put("fiberfox.fibers.scale.z", m_Controls->m_ZscaleBox->value());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
 
     // image generation parameters
     parameters.put("fiberfox.image.basic.size.x", m_ImageGenParameters.imageRegion.GetSize(0));
     parameters.put("fiberfox.image.basic.size.y", m_ImageGenParameters.imageRegion.GetSize(1));
     parameters.put("fiberfox.image.basic.size.z", m_ImageGenParameters.imageRegion.GetSize(2));
     parameters.put("fiberfox.image.basic.spacing.x", m_ImageGenParameters.imageSpacing[0]);
     parameters.put("fiberfox.image.basic.spacing.y", m_ImageGenParameters.imageSpacing[1]);
     parameters.put("fiberfox.image.basic.spacing.z", m_ImageGenParameters.imageSpacing[2]);
     parameters.put("fiberfox.image.basic.numgradients", m_ImageGenParameters.numGradients);
     parameters.put("fiberfox.image.basic.bvalue", m_ImageGenParameters.b_value);
     parameters.put("fiberfox.image.showadvanced", m_Controls->m_AdvancedOptionsBox_2->isChecked());
     parameters.put("fiberfox.image.repetitions", m_ImageGenParameters.repetitions);
     parameters.put("fiberfox.image.signalScale", m_ImageGenParameters.signalScale);
     parameters.put("fiberfox.image.tEcho", m_ImageGenParameters.tEcho);
     parameters.put("fiberfox.image.tLine", m_Controls->m_LineReadoutTimeBox->value());
     parameters.put("fiberfox.image.tInhom", m_ImageGenParameters.tInhom);
     parameters.put("fiberfox.image.axonRadius", m_ImageGenParameters.axonRadius);
     parameters.put("fiberfox.image.interpolationShrink", m_ImageGenParameters.interpolationShrink);
     parameters.put("fiberfox.image.doSimulateRelaxation", m_ImageGenParameters.doSimulateRelaxation);
     parameters.put("fiberfox.image.doDisablePartialVolume", m_ImageGenParameters.doDisablePartialVolume);
     parameters.put("fiberfox.image.outputvolumefractions", m_Controls->m_VolumeFractionsBox->isChecked());
 
     parameters.put("fiberfox.image.artifacts.addnoise", m_Controls->m_AddNoise->isChecked());
     parameters.put("fiberfox.image.artifacts.noisevariance", m_Controls->m_NoiseLevel->value());
     parameters.put("fiberfox.image.artifacts.addghost", m_Controls->m_AddGhosts->isChecked());
     parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_Controls->m_kOffsetBox->value());
     parameters.put("fiberfox.image.artifacts.distortions", m_Controls->m_AddDistortions->isChecked());
     parameters.put("fiberfox.image.artifacts.addeddy", m_Controls->m_AddEddy->isChecked());
     parameters.put("fiberfox.image.artifacts.eddyStrength", m_Controls->m_EddyGradientStrength->value());
     parameters.put("fiberfox.image.artifacts.addringing", m_Controls->m_AddGibbsRinging->isChecked());
     parameters.put("fiberfox.image.artifacts.ringingupsampling", m_Controls->m_ImageUpsamplingBox->value());
     parameters.put("fiberfox.image.artifacts.addspikes", m_Controls->m_AddSpikes->isChecked());
     parameters.put("fiberfox.image.artifacts.spikesnum", m_Controls->m_SpikeNumBox->value());
     parameters.put("fiberfox.image.artifacts.spikesscale", m_Controls->m_SpikeScaleBox->value());
 
     parameters.put("fiberfox.image.compartment1.index", m_Controls->m_Compartment1Box->currentIndex());
     parameters.put("fiberfox.image.compartment2.index", m_Controls->m_Compartment2Box->currentIndex());
     parameters.put("fiberfox.image.compartment3.index", m_Controls->m_Compartment3Box->currentIndex());
     parameters.put("fiberfox.image.compartment4.index", m_Controls->m_Compartment4Box->currentIndex());
 
     parameters.put("fiberfox.image.compartment1.stick.d", m_Controls->m_StickWidget1->GetD());
     parameters.put("fiberfox.image.compartment1.stick.t2", m_Controls->m_StickWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.zeppelin.d1", m_Controls->m_ZeppelinWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.zeppelin.d2", m_Controls->m_ZeppelinWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.zeppelin.t2", m_Controls->m_ZeppelinWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.tensor.d1", m_Controls->m_TensorWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.tensor.d2", m_Controls->m_TensorWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.tensor.d3", m_Controls->m_TensorWidget1->GetD3());
     parameters.put("fiberfox.image.compartment1.tensor.t2", m_Controls->m_TensorWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment2.stick.d", m_Controls->m_StickWidget2->GetD());
     parameters.put("fiberfox.image.compartment2.stick.t2", m_Controls->m_StickWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.zeppelin.d1", m_Controls->m_ZeppelinWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.zeppelin.d2", m_Controls->m_ZeppelinWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.zeppelin.t2", m_Controls->m_ZeppelinWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.tensor.d1", m_Controls->m_TensorWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.tensor.d2", m_Controls->m_TensorWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.tensor.d3", m_Controls->m_TensorWidget2->GetD3());
     parameters.put("fiberfox.image.compartment2.tensor.t2", m_Controls->m_TensorWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment3.ball.d", m_Controls->m_BallWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.ball.t2", m_Controls->m_BallWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.d", m_Controls->m_AstrosticksWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.astrosticks.t2", m_Controls->m_AstrosticksWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.randomize", m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment3.dot.t2", m_Controls->m_DotWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment4.ball.d", m_Controls->m_BallWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.ball.t2", m_Controls->m_BallWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.d", m_Controls->m_AstrosticksWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.astrosticks.t2", m_Controls->m_AstrosticksWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.randomize", m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment4.dot.t2", m_Controls->m_DotWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment4.weight", m_Controls->m_Comp4FractionBox->value());
 
     boost::property_tree::xml_parser::write_xml(filename.toStdString(), parameters);
 }
 
 void QmitkFiberfoxView::LoadParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Fiberfox Parameters (*.ffp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     boost::property_tree::ptree parameters;
     boost::property_tree::xml_parser::read_xml(filename.toStdString(), parameters);
 
     BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameters.get_child("fiberfox") )
     {
         if( v1.first == "fibers" )
         {
             m_Controls->m_RealTimeFibers->setChecked(v1.second.get<bool>("realtime"));
             m_Controls->m_AdvancedOptionsBox->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_DistributionBox->setCurrentIndex(v1.second.get<int>("distribution"));
             m_Controls->m_VarianceBox->setValue(v1.second.get<double>("variance"));
             m_Controls->m_FiberDensityBox->setValue(v1.second.get<int>("density"));
             m_Controls->m_IncludeFiducials->setChecked(v1.second.get<bool>("includeFiducials"));
             m_Controls->m_ConstantRadiusBox->setChecked(v1.second.get<bool>("constantradius"));
 
             BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second )
             {
                 if( v2.first == "spline" )
                 {
                     m_Controls->m_FiberSamplingBox->setValue(v2.second.get<double>("sampling"));
                     m_Controls->m_TensionBox->setValue(v2.second.get<double>("tension"));
                     m_Controls->m_ContinuityBox->setValue(v2.second.get<double>("continuity"));
                     m_Controls->m_BiasBox->setValue(v2.second.get<double>("bias"));
                 }
                 if( v2.first == "rotation" )
                 {
                     m_Controls->m_XrotBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YrotBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZrotBox->setValue(v2.second.get<double>("z"));
                 }
                 if( v2.first == "translation" )
                 {
                     m_Controls->m_XtransBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YtransBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZtransBox->setValue(v2.second.get<double>("z"));
                 }
                 if( v2.first == "scale" )
                 {
                     m_Controls->m_XscaleBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YscaleBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZscaleBox->setValue(v2.second.get<double>("z"));
                 }
             }
         }
         if( v1.first == "image" )
         {
             m_Controls->m_SizeX->setValue(v1.second.get<int>("basic.size.x"));
             m_Controls->m_SizeY->setValue(v1.second.get<int>("basic.size.y"));
             m_Controls->m_SizeZ->setValue(v1.second.get<int>("basic.size.z"));
             m_Controls->m_SpacingX->setValue(v1.second.get<double>("basic.spacing.x"));
             m_Controls->m_SpacingY->setValue(v1.second.get<double>("basic.spacing.y"));
             m_Controls->m_SpacingZ->setValue(v1.second.get<double>("basic.spacing.z"));
             m_Controls->m_NumGradientsBox->setValue(v1.second.get<int>("basic.numgradients"));
             m_Controls->m_BvalueBox->setValue(v1.second.get<int>("basic.bvalue"));
             m_Controls->m_AdvancedOptionsBox_2->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_RepetitionsBox->setValue(v1.second.get<int>("repetitions"));
             m_Controls->m_SignalScaleBox->setValue(v1.second.get<int>("signalScale"));
             m_Controls->m_TEbox->setValue(v1.second.get<double>("tEcho"));
             m_Controls->m_LineReadoutTimeBox->setValue(v1.second.get<double>("tLine"));
             m_Controls->m_T2starBox->setValue(v1.second.get<double>("tInhom"));
             m_Controls->m_FiberRadius->setValue(v1.second.get<double>("axonRadius"));
             m_Controls->m_InterpolationShrink->setValue(v1.second.get<int>("interpolationShrink"));
             m_Controls->m_RelaxationBox->setChecked(v1.second.get<bool>("doSimulateRelaxation"));
             m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(v1.second.get<bool>("doDisablePartialVolume"));
             m_Controls->m_VolumeFractionsBox->setChecked(v1.second.get<bool>("outputvolumefractions"));
 
             m_Controls->m_AddNoise->setChecked(v1.second.get<bool>("artifacts.addnoise"));
             m_Controls->m_NoiseLevel->setValue(v1.second.get<double>("artifacts.noisevariance"));
             m_Controls->m_AddGhosts->setChecked(v1.second.get<bool>("artifacts.addghost"));
             m_Controls->m_kOffsetBox->setValue(v1.second.get<double>("artifacts.kspaceLineOffset"));
             m_Controls->m_AddDistortions->setChecked(v1.second.get<bool>("artifacts.distortions"));
 
             m_Controls->m_AddSpikes->setChecked(v1.second.get<bool>("artifacts.addspikes"));
             m_Controls->m_SpikeNumBox->setValue(v1.second.get<int>("artifacts.spikesnum"));
             m_Controls->m_SpikeScaleBox->setValue(v1.second.get<double>("artifacts.spikesscale"));
             m_Controls->m_AddEddy->setChecked(v1.second.get<bool>("artifacts.addeddy"));
             m_Controls->m_EddyGradientStrength->setValue(v1.second.get<double>("artifacts.eddyStrength"));
             m_Controls->m_AddGibbsRinging->setChecked(v1.second.get<bool>("artifacts.addringing"));
             m_Controls->m_ImageUpsamplingBox->setValue(v1.second.get<double>("artifacts.ringingupsampling"));
 
             m_Controls->m_Compartment1Box->setCurrentIndex(v1.second.get<int>("compartment1.index"));
             m_Controls->m_Compartment2Box->setCurrentIndex(v1.second.get<int>("compartment2.index"));
             m_Controls->m_Compartment3Box->setCurrentIndex(v1.second.get<int>("compartment3.index"));
             m_Controls->m_Compartment4Box->setCurrentIndex(v1.second.get<int>("compartment4.index"));
 
 
             m_Controls->m_StickWidget1->SetD(v1.second.get<double>("compartment1.stick.d"));
             m_Controls->m_StickWidget1->SetT2(v1.second.get<double>("compartment1.stick.t2"));
             m_Controls->m_ZeppelinWidget1->SetD1(v1.second.get<double>("compartment1.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget1->SetD2(v1.second.get<double>("compartment1.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget1->SetT2(v1.second.get<double>("compartment1.zeppelin.t2"));
             m_Controls->m_TensorWidget1->SetD1(v1.second.get<double>("compartment1.tensor.d1"));
             m_Controls->m_TensorWidget1->SetD2(v1.second.get<double>("compartment1.tensor.d2"));
             m_Controls->m_TensorWidget1->SetD3(v1.second.get<double>("compartment1.tensor.d3"));
             m_Controls->m_TensorWidget1->SetT2(v1.second.get<double>("compartment1.tensor.t2"));
 
             m_Controls->m_StickWidget2->SetD(v1.second.get<double>("compartment2.stick.d"));
             m_Controls->m_StickWidget2->SetT2(v1.second.get<double>("compartment2.stick.t2"));
             m_Controls->m_ZeppelinWidget2->SetD1(v1.second.get<double>("compartment2.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget2->SetD2(v1.second.get<double>("compartment2.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget2->SetT2(v1.second.get<double>("compartment2.zeppelin.t2"));
             m_Controls->m_TensorWidget2->SetD1(v1.second.get<double>("compartment2.tensor.d1"));
             m_Controls->m_TensorWidget2->SetD2(v1.second.get<double>("compartment2.tensor.d2"));
             m_Controls->m_TensorWidget2->SetD3(v1.second.get<double>("compartment2.tensor.d3"));
             m_Controls->m_TensorWidget2->SetT2(v1.second.get<double>("compartment2.tensor.t2"));
 
             m_Controls->m_BallWidget1->SetD(v1.second.get<double>("compartment3.ball.d"));
             m_Controls->m_BallWidget1->SetT2(v1.second.get<double>("compartment3.ball.t2"));
             m_Controls->m_AstrosticksWidget1->SetD(v1.second.get<double>("compartment3.astrosticks.d"));
             m_Controls->m_AstrosticksWidget1->SetT2(v1.second.get<double>("compartment3.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(v1.second.get<bool>("compartment3.astrosticks.randomize"));
             m_Controls->m_DotWidget1->SetT2(v1.second.get<double>("compartment3.dot.t2"));
 
             m_Controls->m_BallWidget2->SetD(v1.second.get<double>("compartment4.ball.d"));
             m_Controls->m_BallWidget2->SetT2(v1.second.get<double>("compartment4.ball.t2"));
             m_Controls->m_AstrosticksWidget2->SetD(v1.second.get<double>("compartment4.astrosticks.d"));
             m_Controls->m_AstrosticksWidget2->SetT2(v1.second.get<double>("compartment4.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(v1.second.get<bool>("compartment4.astrosticks.randomize"));
             m_Controls->m_DotWidget2->SetT2(v1.second.get<double>("compartment4.dot.t2"));
 
             m_Controls->m_Comp4FractionBox->setValue(v1.second.get<double>("compartment4.weight"));
         }
     }
     UpdateImageParameters();
 }
 
 void QmitkFiberfoxView::ShowAdvancedOptions(int state)
 {
     if (state)
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedOptionsBox->setChecked(true);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
     }
     else
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedOptionsBox->setChecked(false);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
     }
 }
 
 void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget1->setVisible(false);
     m_Controls->m_ZeppelinWidget1->setVisible(false);
     m_Controls->m_TensorWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_StickWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_ZeppelinWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_TensorWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget2->setVisible(false);
     m_Controls->m_ZeppelinWidget2->setVisible(false);
     m_Controls->m_TensorWidget2->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_StickWidget2->setVisible(true);
         break;
     case 2:
         m_Controls->m_ZeppelinWidget2->setVisible(true);
         break;
     case 3:
         m_Controls->m_TensorWidget2->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget1->setVisible(false);
     m_Controls->m_AstrosticksWidget1->setVisible(false);
     m_Controls->m_DotWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_BallWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_AstrosticksWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_DotWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget2->setVisible(false);
     m_Controls->m_AstrosticksWidget2->setVisible(false);
     m_Controls->m_DotWidget2->setVisible(false);
     m_Controls->m_Comp4FractionFrame->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_BallWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_AstrosticksWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_DotWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::OnConstantRadius(int value)
 {
     if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnAddSpikes(int value)
 {
     if (value>0)
         m_Controls->m_SpikeFrame->setVisible(true);
     else
         m_Controls->m_SpikeFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddEddy(int value)
 {
     if (value>0)
         m_Controls->m_EddyFrame->setVisible(true);
     else
         m_Controls->m_EddyFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddDistortions(int value)
 {
     if (value>0)
         m_Controls->m_DistortionsFrame->setVisible(true);
     else
         m_Controls->m_DistortionsFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGhosts(int value)
 {
     if (value>0)
         m_Controls->m_GhostFrame->setVisible(true);
     else
         m_Controls->m_GhostFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddNoise(int value)
 {
     if (value>0)
         m_Controls->m_NoiseFrame->setVisible(true);
     else
         m_Controls->m_NoiseFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGibbsRinging(int value)
 {
     if (value>0)
         m_Controls->m_GibbsRingingFrame->setVisible(true);
     else
         m_Controls->m_GibbsRingingFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnDistributionChanged(int value)
 {
     if (value==1)
         m_Controls->m_VarianceBox->setVisible(true);
     else
         m_Controls->m_VarianceBox->setVisible(false);
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnVarianceChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
     for (int i=0; i<m_SelectedFiducials.size(); i++)
     {
         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
         mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
         {
             mitk::DataNode::Pointer pFibNode = *it;
             if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer pImgNode = *it2;
                     if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
                     {
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
 
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
 
                         break;
                     }
                 }
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedBundles2.size(); i++ )
     {
         mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
 
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
         {
             mitk::DataNode::Pointer imgNode = *it;
             if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
 
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
 
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
             }
         }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFlipButton()
 {
     if (m_SelectedFiducial.IsNull())
         return;
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
         data.m_Flipped += 1;
         data.m_Flipped %= 2;
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     GradientListType pointshell;
 
     int numB0 = NPoints/20;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     if (NPoints==0)
         return pointshell;
 
     vnl_vector<double> theta; theta.set_size(NPoints);
     vnl_vector<double> phi; phi.set_size(NPoints);
     double C = sqrt(4*M_PI);
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkFiberfoxView::OnAddBundle()
 {
     if (m_SelectedImage.IsNull())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
 
     mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( bundle );
     QString name = QString("Bundle_%1").arg(children->size());
     node->SetName(name.toStdString());
     m_SelectedBundles.push_back(node);
     UpdateGui();
 
     GetDataStorage()->Add(node, m_SelectedImage);
 }
 
 void QmitkFiberfoxView::OnDrawROI()
 {
     if (m_SelectedBundles.empty())
         OnAddBundle();
     if (m_SelectedBundles.empty())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
 
     mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( figure );
 
     QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
     for( int i=0; i<nodes.size(); i++)
         nodes.at(i)->SetSelected(false);
 
     m_SelectedFiducial = node;
 
     QString name = QString("Fiducial_%1").arg(children->size());
     node->SetName(name.toStdString());
     node->SetSelected(true);
 
     this->DisableCrosshairNavigation();
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( node );
     }
 
     UpdateGui();
     GetDataStorage()->Add(node, m_SelectedBundles.at(0));
 }
 
 bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
 {
     int li = -1;
     i->GetPropertyValue("layer", li);
     int lj = -1;
     j->GetPropertyValue("layer", lj);
     return li<lj;
 }
 
 void QmitkFiberfoxView::GenerateFibers()
 {
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedFiducial.IsNull())
             return;
 
         mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
                 m_SelectedBundles.push_back(*it);
 
         if (m_SelectedBundles.empty())
             return;
     }
 
     vector< vector< mitk::PlanarEllipse::Pointer > > fiducials;
     vector< vector< unsigned int > > fliplist;
     for (int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
         std::vector< mitk::DataNode::Pointer > childVector;
         for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
             childVector.push_back(*it);
         sort(childVector.begin(), childVector.end(), CompareLayer);
 
         vector< mitk::PlanarEllipse::Pointer > fib;
         vector< unsigned int > flip;
         float radius = 1;
         int count = 0;
         for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
         {
             mitk::DataNode::Pointer node = *it;
 
             if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
             {
                 mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
                 if (m_Controls->m_ConstantRadiusBox->isChecked())
                 {
                     ellipse->SetTreatAsCircle(true);
                     mitk::Point2D c = ellipse->GetControlPoint(0);
                     mitk::Point2D p = ellipse->GetControlPoint(1);
                     mitk::Vector2D v = p-c;
                     if (count==0)
                     {
                         radius = v.GetVnlVector().magnitude();
                         ellipse->SetControlPoint(1, p);
                     }
                     else
                     {
                         v.Normalize();
                         v *= radius;
                         ellipse->SetControlPoint(1, c+v);
                     }
                 }
                 fib.push_back(ellipse);
 
                 std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
                 if( it != m_DataNodeToPlanarFigureData.end() )
                 {
                     QmitkPlanarFigureData& data = it->second;
                     flip.push_back(data.m_Flipped);
                 }
                 else
                     flip.push_back(0);
             }
             count++;
         }
         if (fib.size()>1)
         {
             fiducials.push_back(fib);
             fliplist.push_back(flip);
         }
         else if (fib.size()>0)
             m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
     filter->SetFiducials(fiducials);
     filter->SetFlipList(fliplist);
 
     switch(m_Controls->m_DistributionBox->currentIndex()){
     case 0:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_UNIFORM);
         break;
     case 1:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_GAUSSIAN);
         filter->SetVariance(m_Controls->m_VarianceBox->value());
         break;
     }
 
     filter->SetDensity(m_Controls->m_FiberDensityBox->value());
     filter->SetTension(m_Controls->m_TensionBox->value());
     filter->SetContinuity(m_Controls->m_ContinuityBox->value());
     filter->SetBias(m_Controls->m_BiasBox->value());
     filter->SetFiberSampling(m_Controls->m_FiberSamplingBox->value());
     filter->Update();
     vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
 
     for (int i=0; i<fiberBundles.size(); i++)
     {
         m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
         if (fiberBundles.at(i)->GetNumFibers()>50000)
             m_SelectedBundles.at(i)->SetVisibility(false);
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::GenerateImage()
 {
     UpdateImageParameters();
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedDWI.IsNotNull()) // add artifacts to existing diffusion weighted image
         {
             for (int i=0; i<m_SelectedImages.size(); i++)
             {
                 if (!dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData()))
                     continue;
 
                 m_SelectedDWI = m_SelectedImages.at(i);
                 UpdateImageParameters();
 
                 mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData());
 
                 mitk::RicianNoiseModel<short> noiseModel;
                 noiseModel.SetNoiseVariance(m_ImageGenParameters.ricianNoiseModel.GetNoiseVariance());
 
                 itk::AddArtifactsToDwiImageFilter< short >::Pointer filter = itk::AddArtifactsToDwiImageFilter< short >::New();
                 filter->SetInput(diffImg->GetVectorImage());
                 filter->SettLine(m_ImageGenParameters.tLine);
                 filter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
                 filter->SetNoiseModel(&noiseModel);
                 filter->SetGradientList(m_ImageGenParameters.gradientDirections);
                 filter->SetTE(m_ImageGenParameters.tEcho);
                 filter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
                 filter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
                 filter->SetUpsampling(m_ImageGenParameters.upsampling);
                 filter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
                 filter->SetSpikeAmplitude(m_ImageGenParameters.spikeAmplitude);
                 filter->SetSpikes(m_ImageGenParameters.spikes);
                 filter->Update();
 
                 mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
                 image->SetVectorImage( filter->GetOutput() );
                 image->SetB_Value(diffImg->GetB_Value());
                 image->SetDirections(diffImg->GetDirections());
                 image->InitializeFromVectorImage();
                 m_ImageGenParameters.resultNode->SetData( image );
                 m_ImageGenParameters.resultNode->SetName(m_SelectedImages.at(i)->GetName()+m_ImageGenParameters.artifactModelString.toStdString());
                 GetDataStorage()->Add(m_ImageGenParameters.resultNode);
             }
             m_SelectedDWI = m_SelectedImages.front();
             return;
         }
 
         mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
                     m_Controls->m_SizeX->value(),
                     m_Controls->m_SizeY->value(),
                     m_Controls->m_SizeZ->value(),
                     m_Controls->m_SpacingX->value(),
                     m_Controls->m_SpacingY->value(),
                     m_Controls->m_SpacingZ->value());
 
         mitk::Geometry3D* geom = image->GetGeometry();
         geom->SetOrigin(m_ImageGenParameters.imageOrigin);
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName("Dummy");
         unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
         unsigned int level = window/2;
         mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
         node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
         GetDataStorage()->Add(node);
         m_SelectedImage = node;
 
         mitk::BaseData::Pointer basedata = node->GetData();
         if (basedata.IsNotNull())
         {
-            mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+            mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
         UpdateGui();
 
         return;
     }
 
     for (int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedBundles.at(i)->GetData());
         if (fiberBundle->GetNumFibers()<=0)
             continue;
 
         itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
 
         tractsToDwiFilter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
         tractsToDwiFilter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
         tractsToDwiFilter->SetUpsampling(m_ImageGenParameters.upsampling);
         tractsToDwiFilter->SetSimulateRelaxation(m_ImageGenParameters.doSimulateRelaxation);
         tractsToDwiFilter->SetImageRegion(m_ImageGenParameters.imageRegion);
         tractsToDwiFilter->SetSpacing(m_ImageGenParameters.imageSpacing);
         tractsToDwiFilter->SetOrigin(m_ImageGenParameters.imageOrigin);
         tractsToDwiFilter->SetDirectionMatrix(m_ImageGenParameters.imageDirection);
         tractsToDwiFilter->SetFiberBundle(fiberBundle);
         tractsToDwiFilter->SetFiberModels(m_ImageGenParameters.fiberModelList);
         tractsToDwiFilter->SetNonFiberModels(m_ImageGenParameters.nonFiberModelList);
         tractsToDwiFilter->SetNoiseModel(&m_ImageGenParameters.ricianNoiseModel);
         tractsToDwiFilter->SetKspaceArtifacts(m_ImageGenParameters.artifactList);
         tractsToDwiFilter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
         tractsToDwiFilter->SettLine(m_ImageGenParameters.tLine);
         tractsToDwiFilter->SettInhom(m_ImageGenParameters.tInhom);
         tractsToDwiFilter->SetTE(m_ImageGenParameters.tEcho);
         tractsToDwiFilter->SetNumberOfRepetitions(m_ImageGenParameters.repetitions);
         tractsToDwiFilter->SetEnforcePureFiberVoxels(m_ImageGenParameters.doDisablePartialVolume);
         tractsToDwiFilter->SetInterpolationShrink(m_ImageGenParameters.interpolationShrink);
         tractsToDwiFilter->SetFiberRadius(m_ImageGenParameters.axonRadius);
         tractsToDwiFilter->SetSignalScale(m_ImageGenParameters.signalScale);
         if (m_ImageGenParameters.interpolationShrink>0)
             tractsToDwiFilter->SetUseInterpolation(true);
         tractsToDwiFilter->SetTissueMask(m_ImageGenParameters.tissueMaskImage);
         tractsToDwiFilter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
         tractsToDwiFilter->SetSpikeAmplitude(m_ImageGenParameters.spikeAmplitude);
         tractsToDwiFilter->SetSpikes(m_ImageGenParameters.spikes);
         tractsToDwiFilter->Update();
 
         mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
         image->SetVectorImage( tractsToDwiFilter->GetOutput() );
         image->SetB_Value(m_ImageGenParameters.b_value);
         image->SetDirections(m_ImageGenParameters.gradientDirections);
         image->InitializeFromVectorImage();
         m_ImageGenParameters.resultNode->SetData( image );
         m_ImageGenParameters.resultNode->SetName(m_SelectedBundles.at(i)->GetName()
                                                  +"_D"+QString::number(m_ImageGenParameters.imageRegion.GetSize(0)).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageRegion.GetSize(1)).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageRegion.GetSize(2)).toStdString()
                                                  +"_S"+QString::number(m_ImageGenParameters.imageSpacing[0]).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageSpacing[1]).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageSpacing[2]).toStdString()
                                                  +"_b"+QString::number(m_ImageGenParameters.b_value).toStdString()
                                                  +"_"+m_ImageGenParameters.signalModelString.toStdString()
                                                  +m_ImageGenParameters.artifactModelString.toStdString());
 
         GetDataStorage()->Add(m_ImageGenParameters.resultNode, m_SelectedBundles.at(i));
 
         m_ImageGenParameters.resultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(tractsToDwiFilter->GetLevelWindow()) );
 
         if (m_Controls->m_VolumeFractionsBox->isChecked())
         {
             std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = tractsToDwiFilter->GetVolumeFractions();
             for (int k=0; k<volumeFractions.size(); k++)
             {
                 mitk::Image::Pointer image = mitk::Image::New();
                 image->InitializeByItk(volumeFractions.at(k).GetPointer());
                 image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
 
                 mitk::DataNode::Pointer node = mitk::DataNode::New();
                 node->SetData( image );
                 node->SetName(m_SelectedBundles.at(i)->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
                 GetDataStorage()->Add(node, m_SelectedBundles.at(i));
             }
         }
 
         mitk::BaseData::Pointer basedata = m_ImageGenParameters.resultNode->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews(
-                        basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+                        basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
     }
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
     vector< mitk::DataNode::Pointer > selectedBundles;
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
                 selectedBundles.push_back(fibNode);
         }
     }
     if (selectedBundles.empty())
         selectedBundles = m_SelectedBundles2;
 
     if (!selectedBundles.empty())
     {
         std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin();
         for (it; it!=selectedBundles.end(); ++it)
         {
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
             fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
             fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
             fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
 
             // handle child fiducials
             if (m_Controls->m_IncludeFiducials->isChecked())
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Geometry3D* geom = pe->GetGeometry();
 
                         // translate
                         mitk::Vector3D world;
                         world[0] = m_Controls->m_XtransBox->value();
                         world[1] = m_Controls->m_YtransBox->value();
                         world[2] = m_Controls->m_ZtransBox->value();
                         geom->Translate(world);
 
                         // calculate rotation matrix
                         double x = m_Controls->m_XrotBox->value()*M_PI/180;
                         double y = m_Controls->m_YrotBox->value()*M_PI/180;
                         double z = m_Controls->m_ZrotBox->value()*M_PI/180;
 
                         itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
                         rotX[1][1] = cos(x);
                         rotX[2][2] = rotX[1][1];
                         rotX[1][2] = -sin(x);
                         rotX[2][1] = -rotX[1][2];
 
                         itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
                         rotY[0][0] = cos(y);
                         rotY[2][2] = rotY[0][0];
                         rotY[0][2] = sin(y);
                         rotY[2][0] = -rotY[0][2];
 
                         itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
                         rotZ[0][0] = cos(z);
                         rotZ[1][1] = rotZ[0][0];
                         rotZ[0][1] = -sin(z);
                         rotZ[1][0] = -rotZ[0][1];
 
                         itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
 
                         // transform control point coordinate into geometry translation
                         geom->SetOrigin(pe->GetWorldControlPoint(0));
                         mitk::Point2D cp; cp.Fill(0.0);
                         pe->SetControlPoint(0, cp);
 
                         // rotate fiducial
                         geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
 
                         // implicit translation
                         mitk::Vector3D trans;
                         trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
                         trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
                         trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
                         mitk::Vector3D newWc = rot*trans;
                         newWc = newWc-trans;
                         geom->Translate(newWc);
                     }
                 }
             }
         }
     }
     else
     {
         for (int i=0; i<m_SelectedFiducials.size(); i++)
         {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
             mitk::Geometry3D* geom = pe->GetGeometry();
 
             // translate
             mitk::Vector3D world;
             world[0] = m_Controls->m_XtransBox->value();
             world[1] = m_Controls->m_YtransBox->value();
             world[2] = m_Controls->m_ZtransBox->value();
             geom->Translate(world);
 
             // calculate rotation matrix
             double x = m_Controls->m_XrotBox->value()*M_PI/180;
             double y = m_Controls->m_YrotBox->value()*M_PI/180;
             double z = m_Controls->m_ZrotBox->value()*M_PI/180;
             itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
             rotX[1][1] = cos(x);
             rotX[2][2] = rotX[1][1];
             rotX[1][2] = -sin(x);
             rotX[2][1] = -rotX[1][2];
             itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
             rotY[0][0] = cos(y);
             rotY[2][2] = rotY[0][0];
             rotY[0][2] = sin(y);
             rotY[2][0] = -rotY[0][2];
             itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
             rotZ[0][0] = cos(z);
             rotZ[1][1] = rotZ[0][0];
             rotZ[0][1] = -sin(z);
             rotZ[1][0] = -rotZ[0][1];
             itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
 
             // transform control point coordinate into geometry translation
             geom->SetOrigin(pe->GetWorldControlPoint(0));
             mitk::Point2D cp; cp.Fill(0.0);
             pe->SetControlPoint(0, cp);
 
             // rotate fiducial
             geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
         }
         if (m_Controls->m_RealTimeFibers->isChecked())
             GenerateFibers();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::CopyBundles()
 {
     if ( m_SelectedBundles.size()<1 ){
         QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         // find parent image
         mitk::DataNode::Pointer parentNode;
         mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
         {
             mitk::DataNode::Pointer pImgNode = *it2;
             if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
             {
                 parentNode = pImgNode;
                 break;
             }
         }
 
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
         mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
         QString name((*it)->GetName().c_str());
         name += "_copy";
 
         mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
         fbNode->SetData(newBundle);
         fbNode->SetName(name.toStdString());
         fbNode->SetVisibility(true);
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(fbNode, parentNode);
         else
             GetDataStorage()->Add(fbNode);
 
         // copy child fiducials
         if (m_Controls->m_IncludeFiducials->isChecked())
         {
             mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
             for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
             {
                 mitk::DataNode::Pointer fiducialNode = *it2;
                 if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                 {
                     mitk::PlanarEllipse::Pointer pe = mitk::PlanarEllipse::New();
                     pe->DeepCopy(dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()));
                     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
                     newNode->SetData(pe);
                     newNode->SetName(fiducialNode->GetName());
                     GetDataStorage()->Add(newNode, fbNode);
                 }
             }
         }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::JoinBundles()
 {
     if ( m_SelectedBundles.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
     QString name("");
     name += QString((*it)->GetName().c_str());
     ++it;
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
         name += "+"+QString((*it)->GetName().c_str());
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::UpdateGui()
 {
     m_Controls->m_FiberBundleLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_GeometryFrame->setEnabled(true);
     m_Controls->m_GeometryMessage->setVisible(false);
     m_Controls->m_DiffusionPropsMessage->setVisible(false);
     m_Controls->m_FiberGenMessage->setVisible(true);
 
     m_Controls->m_TransformBundlesButton->setEnabled(false);
     m_Controls->m_CopyBundlesButton->setEnabled(false);
     m_Controls->m_GenerateFibersButton->setEnabled(false);
     m_Controls->m_FlipButton->setEnabled(false);
     m_Controls->m_CircleButton->setEnabled(false);
     m_Controls->m_BvalueBox->setEnabled(true);
     m_Controls->m_NumGradientsBox->setEnabled(true);
     m_Controls->m_JoinBundlesButton->setEnabled(false);
     m_Controls->m_AlignOnGrid->setEnabled(false);
 
     if (m_SelectedFiducial.IsNotNull())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_FlipButton->setEnabled(true);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_CircleButton->setEnabled(true);
         m_Controls->m_FiberGenMessage->setVisible(false);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_TissueMask.IsNotNull() || m_SelectedImage.IsNotNull())
     {
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (m_SelectedDWI.IsNotNull())
     {
         m_Controls->m_DiffusionPropsMessage->setVisible(true);
         m_Controls->m_BvalueBox->setEnabled(false);
         m_Controls->m_NumGradientsBox->setEnabled(false);
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (!m_SelectedBundles.empty())
     {
         m_Controls->m_CopyBundlesButton->setEnabled(true);
         m_Controls->m_GenerateFibersButton->setEnabled(true);
         m_Controls->m_FiberBundleLabel->setText(m_SelectedBundles.at(0)->GetName().c_str());
 
         if (m_SelectedBundles.size()>1)
             m_Controls->m_JoinBundlesButton->setEnabled(true);
     }
 }
 
 void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
 {
     m_SelectedBundles2.clear();
     m_SelectedImages.clear();
     m_SelectedFiducials.clear();
     m_SelectedFiducial = NULL;
     m_TissueMask = NULL;
     m_SelectedBundles.clear();
     m_SelectedImage = NULL;
     m_SelectedDWI = NULL;
     m_Controls->m_TissueMaskLabel->setText("<font color='grey'>optional</font>");
 
     // iterate all selected objects, adjust warning visibility
     for( int i=0; i<nodes.size(); i++)
     {
         mitk::DataNode::Pointer node = nodes.at(i);
 
         if ( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
         {
             m_SelectedDWI = node;
             m_SelectedImage = node;
             m_SelectedImages.push_back(node);
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             m_SelectedImages.push_back(node);
             m_SelectedImage = node;
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
             {
                 m_TissueMask = dynamic_cast<mitk::Image*>(node->GetData());
                 m_Controls->m_TissueMaskLabel->setText(node->GetName().c_str());
             }
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_SelectedBundles2.push_back(node);
             if (m_Controls->m_RealTimeFibers->isChecked())
             {
                 m_SelectedBundles.push_back(node);
                 mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
                 if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
                     GenerateFibers();
             }
             else
                 m_SelectedBundles.push_back(node);
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
         {
             m_SelectedFiducials.push_back(node);
             m_SelectedFiducial = node;
             m_SelectedBundles.clear();
             mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
             for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             {
                 mitk::DataNode::Pointer pNode = *it;
                 if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
                     m_SelectedBundles.push_back(pNode);
             }
         }
     }
     UpdateGui();
 }
 
 
 void QmitkFiberfoxView::EnableCrosshairNavigation()
 {
     MITK_DEBUG << "EnableCrosshairNavigation";
 
     // enable the crosshair navigation
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "enabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(true);
         //        linkedRenderWindow->EnableSlicingPlanes(true);
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::DisableCrosshairNavigation()
 {
     MITK_DEBUG << "DisableCrosshairNavigation";
 
     // disable the crosshair navigation during the drawing
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "disabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(false);
         //        linkedRenderWindow->EnableSlicingPlanes(false);
     }
 }
 
 void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
 
     if (dynamic_cast<FiberBundleX*>(node->GetData()))
     {
         m_SelectedBundles.clear();
         m_SelectedBundles2.clear();
     }
     else if (dynamic_cast<Image*>(node->GetData()))
         m_SelectedImages.clear();
 
     if( it != 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 );
 
         m_DataNodeToPlanarFigureData.erase( it );
     }
 }
 
 void QmitkFiberfoxView::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 )
     {
         MITK_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( "PlanarFigure" );
           figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
           figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
           figureInteractor->SetDataNode( nonConstNode );
         }
 
         MITK_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< QmitkFiberfoxView > SimpleCommandType;
         //        SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
         //        initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
         //        data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
         // add observer for event when figure is picked (selected)
         typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
         MemberCommandType::Pointer selectCommand = MemberCommandType::New();
         selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::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, &QmitkFiberfoxView::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, &QmitkFiberfoxView::EnableCrosshairNavigation);
         data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
         m_DataNodeToPlanarFigureData[nonConstNode] = data;
     }
 }
 
 void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
     for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
     {
         mitk::DataNode* node = *it;
 
         if( node->GetData() == object )
         {
             node->SetSelected(true);
             m_SelectedFiducial = node;
         }
         else
             node->SetSelected(false);
     }
     UpdateGui();
     this->RequestRenderWindowUpdate();
 }
 
 void QmitkFiberfoxView::SetFocus()
 {
     m_Controls->m_CircleButton->setFocus();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
index 5683c2355d..7abf5622b5 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
@@ -1,826 +1,826 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIVIMView.h"
 #include "QmitkStdMultiWidget.h"
 
 // qt
 #include "qmessagebox.h"
 #include "qclipboard.h"
 
 // mitk
 #include "mitkDiffusionImage.h"
 #include "mitkImageCast.h"
 
 // itk
 #include "itkScalarImageToHistogramGenerator.h"
 #include "itkRegionOfInterestImageFilter.h"
 #include "itkImageRegionConstIteratorWithIndex.h"
 
 // itk/mitk
 #include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
 #include "itkRegularizedIVIMReconstructionFilter.h"
 #include "mitkImageCast.h"
 
 const std::string QmitkIVIMView::VIEW_ID = "org.mitk.views.ivim";
 
 QmitkIVIMView::QmitkIVIMView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_SliceObserverTag1(0), m_SliceObserverTag2(0), m_SliceObserverTag3(0)
     , m_DiffusionImageNode(NULL)
     , m_MaskImageNode(NULL)
     , m_Active(false)
 {
 }
 
 QmitkIVIMView::~QmitkIVIMView()
 {
 //    QmitkStdMultiWidget* MultiWidget = this->GetActiveStdMultiWidget(false);
 
 //    if(MultiWidget)
 //    {
 //        //unregister observers when view is destroyed
 //        if( MultiWidget->mitkWidget1 != NULL && m_SliceObserverTag1 != 0)
 //        {
 //            mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget1->GetSliceNavigationController();
 //            slicer->RemoveObserver( m_SliceObserverTag1 );
 //        }
 
 //        if( MultiWidget->mitkWidget2 != NULL && m_SliceObserverTag2 != 0)
 //        {
 //            mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget2->GetSliceNavigationController();
 //            slicer->RemoveObserver( m_SliceObserverTag2 );
 //        }
 
 //        if( MultiWidget->mitkWidget3!= NULL && m_SliceObserverTag3 != 0)
 //        {
 //            mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget3->GetSliceNavigationController();
 //            slicer->RemoveObserver( m_SliceObserverTag3 );
 //        }
 //    }
 }
 
 void QmitkIVIMView::CreateQtPartControl( QWidget *parent )
 {
 
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkIVIMViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_ButtonStart, SIGNAL(clicked()), this, SLOT(FittIVIMStart()) );
         connect( m_Controls->m_ButtonAutoThres, SIGNAL(clicked()), this, SLOT(AutoThreshold()) );
 
         connect( m_Controls->m_MethodCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(MethodCombo(int)) );
 
         connect( m_Controls->m_DStarSlider, SIGNAL(valueChanged(int)), this, SLOT(DStarSlider(int)) );
         connect( m_Controls->m_BThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(BThreshSlider(int)) );
         connect( m_Controls->m_S0ThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(S0ThreshSlider(int)) );
         connect( m_Controls->m_NumItSlider, SIGNAL(valueChanged(int)), this, SLOT(NumItsSlider(int)) );
         connect( m_Controls->m_LambdaSlider, SIGNAL(valueChanged(int)), this, SLOT(LambdaSlider(int)) );
 
         connect( m_Controls->m_CheckDStar, SIGNAL(clicked()), this, SLOT(Checkbox()) );
         connect( m_Controls->m_CheckD, SIGNAL(clicked()), this, SLOT(Checkbox()) );
         connect( m_Controls->m_Checkf, SIGNAL(clicked()), this, SLOT(Checkbox()) );
 
         connect( m_Controls->m_ChooseMethod, SIGNAL(clicked()), this, SLOT(ChooseMethod()) );
         connect( m_Controls->m_CurveClipboard, SIGNAL(clicked()), this, SLOT(ClipboardCurveButtonClicked()) );
         connect( m_Controls->m_ValuesClipboard, SIGNAL(clicked()), this, SLOT(ClipboardStatisticsButtonClicked()) );
 
     }
 
     QString dstar = QString::number(m_Controls->m_DStarSlider->value()/1000.0);
     m_Controls->m_DStarLabel->setText(dstar);
 
     QString bthresh = QString::number(m_Controls->m_BThreshSlider->value()*5.0);
     m_Controls->m_BThreshLabel->setText(bthresh);
 
     QString s0thresh = QString::number(m_Controls->m_S0ThreshSlider->value()*0.5);
     m_Controls->m_S0ThreshLabel->setText(s0thresh);
 
     QString numits = QString::number(m_Controls->m_NumItSlider->value());
     m_Controls->m_NumItsLabel->setText(numits);
 
     QString lambda = QString::number(m_Controls->m_LambdaSlider->value()*.00001);
     m_Controls->m_LambdaLabel->setText(lambda);
 
     m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
     m_Controls->m_Warning->setVisible(false);
 
     MethodCombo(m_Controls->m_MethodCombo->currentIndex());
 
 }
 
 void QmitkIVIMView::Checkbox()
 {
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::MethodCombo(int val)
 {
     switch(val)
     {
     case 0:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 1:
         m_Controls->m_DstarFrame->setVisible(true);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 2:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(true);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 3:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(true);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 4:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(false);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     }
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::DStarSlider (int val)
 {
     QString sval = QString::number(val/1000.0);
     m_Controls->m_DStarLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::BThreshSlider (int val)
 {
     QString sval = QString::number(val*5.0);
     m_Controls->m_BThreshLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::S0ThreshSlider (int val)
 {
     QString sval = QString::number(val*0.5);
     m_Controls->m_S0ThreshLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::NumItsSlider (int val)
 {
     QString sval = QString::number(val);
     m_Controls->m_NumItsLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::LambdaSlider (int val)
 {
     QString sval = QString::number(val*.00001);
     m_Controls->m_LambdaLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
 }
 
 void QmitkIVIMView::StdMultiWidgetNotAvailable()
 {
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag1 );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag2 );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag3 );
     }
 
     m_MultiWidget = NULL;
 }
 
 void QmitkIVIMView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     bool foundOneDiffusionImage = false;
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
     m_MaskImageNode = NULL;
     m_DiffusionImageNode = NULL;
 
     // iterate all selected objects, adjust warning visibility
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
             {
                 m_DiffusionImageNode = node;
                 foundOneDiffusionImage = true;
                 m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary)
                 {
                     m_MaskImageNode = node;
                     m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if (m_DiffusionImageNode.IsNotNull())
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(true);
         m_Controls->m_InputData->setTitle("Input Data");
     }
     else
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(false);
         m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     }
 
     m_Controls->m_ButtonStart->setEnabled( foundOneDiffusionImage );
     m_Controls->m_ButtonAutoThres->setEnabled( foundOneDiffusionImage );
 
     m_Controls->m_ControlsFrame->setEnabled( foundOneDiffusionImage );
     m_Controls->m_BottomControlsFrame->setEnabled( foundOneDiffusionImage );
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::AutoThreshold()
 {
     std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
     if (nodes.empty()) return;
 
     if (!nodes.front())
     {
         // Nothing selected. Inform the user and return
         QMessageBox::information( NULL, "Template", "Please load and select a diffusion image before starting image processing.");
         return;
     }
 
     typedef mitk::DiffusionImage<short> DiffImgType;
     DiffImgType* dimg = dynamic_cast<DiffImgType*>(nodes.front()->GetData());
 
     if (!dimg)
     {
         // Nothing selected. Inform the user and return
         QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
         return;
     }
 
     // find bzero index
     int index = -1;
     DiffImgType::GradientDirectionContainerType::Pointer directions = dimg->GetDirections();
     for(DiffImgType::GradientDirectionContainerType::ConstIterator it = directions->Begin();
         it != directions->End(); ++it)
     {
         index++;
         DiffImgType::GradientDirectionType g = it.Value();
         if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
             break;
     }
 
     typedef itk::VectorImage<short,3> VecImgType;
     VecImgType::Pointer vecimg = dimg->GetVectorImage();
 
     int vecLength = vecimg->GetVectorLength();
     index = index > vecLength-1 ? vecLength-1 : index;
 
     MITK_INFO << "Performing Histogram Analysis on Channel" << index;
 
     typedef itk::Image<short,3> ImgType;
     ImgType::Pointer img = ImgType::New();
     mitk::CastToItkImage<ImgType>(dimg, img);
 
     itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
     itw.GoToBegin();
 
     itk::ImageRegionConstIterator<VecImgType> itr (vecimg, vecimg->GetLargestPossibleRegion() );
     itr.GoToBegin();
 
     while(!itr.IsAtEnd())
     {
         itw.Set(itr.Get().GetElement(index));
         ++itr;
         ++itw;
     }
 
     typedef itk::Statistics::ScalarImageToHistogramGenerator< ImgType >
             HistogramGeneratorType;
     typedef HistogramGeneratorType::HistogramType HistogramType;
 
     HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
     histogramGenerator->SetInput( img );
     histogramGenerator->SetMarginalScale( 10 ); // Defines y-margin width of histogram
     histogramGenerator->SetNumberOfBins( 100 ); // CT range [-1024, +2048] --> bin size 4 values
     histogramGenerator->SetHistogramMin(  dimg->GetScalarValueMin() );
     histogramGenerator->SetHistogramMax(  dimg->GetScalarValueMax() * .5 );
     histogramGenerator->Compute();
 
     HistogramType::ConstIterator iter = histogramGenerator->GetOutput()->Begin();
     float maxFreq = 0;
     float maxValue = 0;
     while ( iter != histogramGenerator->GetOutput()->End() )
     {
         if(iter.GetFrequency() > maxFreq)
         {
             maxFreq = iter.GetFrequency();
             maxValue = iter.GetMeasurementVector()[0];
         }
         ++iter;
     }
 
     maxValue *= 2;
 
     int sliderPos = maxValue * 2;
     m_Controls->m_S0ThreshSlider->setValue(sliderPos);
     S0ThreshSlider(sliderPos);
 }
 
 void QmitkIVIMView::FittIVIMStart()
 {
 
     std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
     mitk::DiffusionImage<short>* img = 0;
     for ( unsigned int i=0; i<nodes.size(); i++ )
     {
         img = dynamic_cast<mitk::DiffusionImage<short>*>(nodes.at(i)->GetData());
         if (img)
             break;
     }
     if (!img)
     {
         QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
         return;
     }
 
     typedef itk::VectorImage<short,3> VecImgType;
     VecImgType::Pointer vecimg = img->GetVectorImage();
 
     OutImgType::IndexType dummy;
 
     FittIVIM(vecimg, img->GetDirections(), img->GetB_Value(), true, dummy);
     OutputToDatastorage(nodes);
 }
 
 void QmitkIVIMView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
     if(!m_Visible)
         return;
 
     m_Controls->m_Warning->setVisible(false);
     if(!m_Controls || m_DiffusionImageNode.IsNull())
         return;
 
     m_Controls->m_VisualizeResultsWidget->setVisible(false);
 
     mitk::DiffusionImage<short>::Pointer diffusionImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_DiffusionImageNode->GetData());
     mitk::Image::Pointer maskImg = NULL;
     if (m_MaskImageNode.IsNotNull())
         maskImg = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
 
     if (!m_MultiWidget) return;
 
     typedef itk::VectorImage<short,3> VecImgType;
     VecImgType::Pointer vecimg = (VecImgType*)diffusionImg->GetVectorImage().GetPointer();
 
     VecImgType::Pointer roiImage = VecImgType::New();
 
     bool success = false;
     if(maskImg.IsNull())
     {
         int roisize = 0;
         if(m_Controls->m_MethodCombo->currentIndex() == 4)
             roisize = 5;
 
         mitk::Point3D pos = m_MultiWidget->GetCrossPosition();
 
         VecImgType::IndexType crosspos;
-        diffusionImg->GetTimeSlicedGeometry()->WorldToIndex(pos, crosspos);
+        diffusionImg->GetGeometry()->WorldToIndex(pos, crosspos);
         if (!vecimg->GetLargestPossibleRegion().IsInside(crosspos))
         {
             m_Controls->m_Warning->setText(QString("Crosshair position not inside of selected diffusion weighted image. Reinit needed!"));
             m_Controls->m_Warning->setVisible(true);
             return;
         }
         else
             m_Controls->m_Warning->setVisible(false);
 
         VecImgType::IndexType index;
         index[0] = crosspos[0] - roisize; index[0] = index[0] < 0 ? 0 : index[0];
         index[1] = crosspos[1] - roisize; index[1] = index[1] < 0 ? 0 : index[1];
         index[2] = crosspos[2] - roisize; index[2] = index[2] < 0 ? 0 : index[2];
 
         VecImgType::SizeType size;
         size[0] = roisize*2+1;
         size[1] = roisize*2+1;
         size[2] = roisize*2+1;
 
         VecImgType::SizeType maxSize = vecimg->GetLargestPossibleRegion().GetSize();
         size[0] = index[0]+size[0] > maxSize[0] ? maxSize[0]-index[0] : size[0];
         size[1] = index[1]+size[1] > maxSize[1] ? maxSize[1]-index[1] : size[1];
         size[2] = index[2]+size[2] > maxSize[2] ? maxSize[2]-index[2] : size[2];
 
         VecImgType::RegionType region;
         region.SetSize( size );
         region.SetIndex( index );
         vecimg->SetRequestedRegion( region );
 
         VecImgType::IndexType  newstart;
         newstart.Fill(0);
 
         VecImgType::RegionType newregion;
         newregion.SetSize( size );
         newregion.SetIndex( newstart );
 
         roiImage->CopyInformation( vecimg );
         roiImage->SetRegions( newregion );
         roiImage->SetOrigin( pos );
         roiImage->Allocate();
         roiImage->SetPixel(newstart, vecimg->GetPixel(index));
 
         success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetB_Value(), false, crosspos);
     }
     else
     {
         typedef itk::Image<float,3> MaskImgType;
 
         MaskImgType::Pointer maskItk;
         CastToItkImage( maskImg, maskItk );
 
         mitk::Point3D pos;
         pos[0] = 0;
         pos[1] = 0;
         pos[2] = 0;
 
         VecImgType::IndexType index;
         index[0] = 0;
         index[1] = 0;
         index[2] = 0;
 
         VecImgType::SizeType size;
         size[0] = 1;
         size[1] = 1;
         size[2] = 1;
 
         VecImgType::RegionType region;
         region.SetSize( size );
         region.SetIndex( index );
         vecimg->SetRequestedRegion( region );
 
         // iterators over output and input
         itk::ImageRegionConstIteratorWithIndex<VecImgType>
                 vecit(vecimg, vecimg->GetLargestPossibleRegion());
 
         itk::VariableLengthVector<double> avg(vecimg->GetVectorLength());
         avg.Fill(0);
 
         float numPixels = 0;
         while ( ! vecit.IsAtEnd() )
         {
             VecImgType::PointType point;
             vecimg->TransformIndexToPhysicalPoint(vecit.GetIndex(), point);
 
             MaskImgType::IndexType index;
             maskItk->TransformPhysicalPointToIndex(point, index);
 
             if(maskItk->GetPixel(index) != 0)
             {
                 avg += vecit.Get();
                 numPixels += 1.0;
             }
 
             // update iterators
             ++vecit;
 
         }
 
         avg /= numPixels;
 
         m_Controls->m_Warning->setText(QString("Averaging ")+QString::number((int)numPixels)+QString(" voxels!"));
         m_Controls->m_Warning->setVisible(true);
 
         roiImage->CopyInformation( vecimg );
         roiImage->SetRegions( region );
         roiImage->SetOrigin( pos );
         roiImage->Allocate();
         roiImage->SetPixel(index, avg);
 
         success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetB_Value(), false, index);
     }
 
     vecimg->SetRegions( vecimg->GetLargestPossibleRegion() );
 
     if (success)
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(true);
         m_Controls->m_VisualizeResultsWidget->SetParameters(m_Snap);
     }
 }
 
 bool QmitkIVIMView::FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos)
 {
     IVIMFilterType::Pointer filter = IVIMFilterType::New();
     filter->SetInput(vecimg);
     filter->SetGradientDirections(dirs);
     filter->SetBValue(bval);
 
     switch(m_Controls->m_MethodCombo->currentIndex())
     {
 
     case 0:
         filter->SetMethod(IVIMFilterType::IVIM_FIT_ALL);
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         break;
 
     case 1:
         filter->SetMethod(IVIMFilterType::IVIM_DSTAR_FIX);
         filter->SetDStar(m_Controls->m_DStarLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         break;
 
     case 2:
         filter->SetMethod(IVIMFilterType::IVIM_D_THEN_DSTAR);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
 
     case 3:
         filter->SetMethod(IVIMFilterType::IVIM_LINEAR_D_THEN_F);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
 
     case 4:
         filter->SetMethod(IVIMFilterType::IVIM_REGULARIZED);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetNumberIterations(m_Controls->m_NumItsLabel->text().toInt());
         filter->SetLambda(m_Controls->m_LambdaLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
     }
 
     if(!multivoxel)
     {
         filter->SetFitDStar(true);
     }
 
     filter->SetNumberOfThreads(1);
     filter->SetVerbose(false);
     filter->SetCrossPosition(crosspos);
 
     try{
         filter->Update();
         m_Snap = filter->GetSnapshot();
         m_DStarMap = filter->GetOutput(2);
         m_DMap = filter->GetOutput(1);
         m_fMap = filter->GetOutput();
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         m_Controls->m_Warning->setText(QString("IVIM fit not possible: ")+ex.GetDescription());
         m_Controls->m_Warning->setVisible(true);
         return false;
     }
     return true;
 }
 
 void QmitkIVIMView::OutputToDatastorage(std::vector<mitk::DataNode*> nodes)
 {
     // Outputs to Datastorage
     QString basename(nodes.front()->GetName().c_str());
 
     if(m_Controls->m_CheckDStar->isChecked())
     {
         mitk::Image::Pointer dstarimage = mitk::Image::New();
         dstarimage->InitializeByItk(m_DStarMap.GetPointer());
         dstarimage->SetVolume(m_DStarMap->GetBufferPointer());
         QString newname2 = basename; newname2 = newname2.append("_DStarMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node2=mitk::DataNode::New();
         node2->SetData( dstarimage );
         node2->SetName(newname2.toAscii());
         GetDefaultDataStorage()->Add(node2);
     }
 
     if(m_Controls->m_CheckD->isChecked())
     {
         mitk::Image::Pointer dimage = mitk::Image::New();
         dimage->InitializeByItk(m_DMap.GetPointer());
         dimage->SetVolume(m_DMap->GetBufferPointer());
         QString newname1 = basename; newname1 = newname1.append("_DMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node1=mitk::DataNode::New();
         node1->SetData( dimage );
         node1->SetName(newname1.toAscii());
         GetDefaultDataStorage()->Add(node1);
     }
 
     if(m_Controls->m_Checkf->isChecked())
     {
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk(m_fMap.GetPointer());
         image->SetVolume(m_fMap->GetBufferPointer());
         QString newname0 = basename; newname0 = newname0.append("_fMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node=mitk::DataNode::New();
         node->SetData( image );
         node->SetName(newname0.toAscii());
         GetDefaultDataStorage()->Add(node);
     }
 
     m_MultiWidget->RequestUpdate();
 
     // reset the data node labels, the selection in DataManager is lost after adding
     // a new node -> we cannot directly proceed twice, the DWI ( and MASK) image have to be selected again
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
     m_MaskImageNode = NULL;
     m_DiffusionImageNode = NULL;
 
 }
 
 void QmitkIVIMView::ChooseMethod()
 {
     m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
 }
 
 void QmitkIVIMView::ClipboardCurveButtonClicked()
 {
     if(true)
     {
 
         QString clipboard("Measurement Points\n");
         for ( unsigned int i=0; i<m_Snap.bvalues.size(); i++)
         {
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( m_Snap.bvalues[i], 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         for ( unsigned int i=0; i<m_Snap.allmeas.size(); i++)
         {
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( m_Snap.allmeas[i], 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
 
         clipboard = clipboard.append( "1st Linear Fit of D and f \n" );
         double maxb = m_Snap.bvalues.max_value();
         clipboard = clipboard.append( "%L1 \t %L2 \n %L3 \t %L4 \n" )
                 .arg( (float) 0, 0, 'f', 2 )
                 .arg( maxb, 0, 'f', 2 )
                 .arg(1-m_Snap.currentFunceiled, 0, 'f', 2 )
                 .arg((1-m_Snap.currentFunceiled)*exp(-maxb * m_Snap.currentD), 0, 'f', 2 );
 
 
         int nsampling = 50;
         double f = 1-m_Snap.currentFunceiled;
         clipboard = clipboard.append("Final Model\n");
         for(int i=0; i<nsampling; i++)
         {
             double x = (((1.0)*i)/(1.0*nsampling))*maxb;
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( x, 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         for(int i=0; i<nsampling; i++)
         {
             double x = (((1.0)*i)/(1.0*nsampling))*maxb;
             double y = f*exp(- x * m_Snap.currentD) + (1-f)*exp(- x * (m_Snap.currentD+m_Snap.currentDStar));
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( y, 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         QApplication::clipboard()->setText(
                     clipboard, QClipboard::Clipboard );
     }
     else
     {
         QApplication::clipboard()->clear();
     }
 }
 
 
 void QmitkIVIMView::ClipboardStatisticsButtonClicked()
 {
     if ( true )
     {
 
         QString clipboard( "f \t D \t D* \n" );
         clipboard = clipboard.append( "%L1 \t %L2 \t %L3" )
                 .arg( m_Snap.currentF, 0, 'f', 10 )
                 .arg( m_Snap.currentD, 0, 'f', 10 )
                 .arg( m_Snap.currentDStar, 0, 'f', 10 ) ;
 
         QApplication::clipboard()->setText(
                     clipboard, QClipboard::Clipboard );
     }
     else
     {
         QApplication::clipboard()->clear();
     }
 }
 
 void QmitkIVIMView::Activated()
 {
     m_Active = true;
 }
 
 void QmitkIVIMView::Deactivated()
 {
     m_Active = false;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
index 91fb6a4289..89fa93dd37 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
@@ -1,366 +1,366 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkODFDetailsView.h"
 #include <QmitkStdMultiWidget.h>
 #include <QTableWidgetItem>
 #include <vtkFloatArray.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkLookupTable.h>
 #include <mitkOdfNormalizationMethodProperty.h>
 #include <QTextEdit>
 #include <mitkTensorImage.h>
 #include <QMessageBox>
 #include <QmitkRenderingManager.h>
 
 #include <mitkImageReadAccessor.h>
 
 const std::string QmitkODFDetailsView::VIEW_ID = "org.mitk.views.odfdetails";
 
 QmitkODFDetailsView::QmitkODFDetailsView()
   : QmitkFunctionality()
   , m_Controls( 0 )
   , m_MultiWidget( NULL )
   , m_OdfNormalization(0)
   , m_ImageNode(NULL)
 {
   m_VtkActor = vtkActor::New();
   m_VtkMapper = vtkPolyDataMapper::New();
   m_Renderer = vtkRenderer::New();
   m_VtkRenderWindow = vtkRenderWindow::New();
   m_RenderWindowInteractor = vtkRenderWindowInteractor::New();
   m_Camera = vtkCamera::New();
   m_VtkRenderWindow->SetSize(300,300);
 }
 
 QmitkODFDetailsView::~QmitkODFDetailsView()
 {
 
 }
 
 void QmitkODFDetailsView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkODFDetailsViewControls;
     m_Controls->setupUi( parent );
     m_Controls->m_OdfBox->setVisible(false);
     m_Controls->m_ODFRenderWidget->setVisible(false);
   }
 }
 
 void QmitkODFDetailsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
   }
 }
 
 void QmitkODFDetailsView::StdMultiWidgetNotAvailable()
 {
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
     slicer->RemoveObserver( m_SliceObserverTag1 );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
     slicer->RemoveObserver( m_SliceObserverTag2 );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
     slicer->RemoveObserver( m_SliceObserverTag3 );
   }
 
   m_MultiWidget = NULL;
 }
 
 void QmitkODFDetailsView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
   if (m_ImageNode.IsNotNull())
     m_ImageNode->RemoveObserver( m_PropertyObserverTag );
 
   m_Controls->m_InputData->setTitle("Please Select Input Data");
   m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
 
   m_ImageNode = NULL;
 
   // iterate selection
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(node->GetData()) || dynamic_cast<mitk::TensorImage*>(node->GetData())) )
     {
       m_Controls->m_InputImageLabel->setText(node->GetName().c_str());
       m_ImageNode = node;
     }
   }
 
   UpdateOdf();
   if (m_ImageNode.IsNotNull())
   {
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_PropertyObserverTag = m_ImageNode->AddObserver( itk::ModifiedEvent(), command );
 
     m_Controls->m_InputData->setTitle("Input Data");
   }
 }
 
 void QmitkODFDetailsView::UpdateOdf()
 {
 
   try
   {
     m_Controls->m_OverviewBox->setVisible(true);
     if (m_ImageNode.IsNull() || !m_MultiWidget)
     {
       m_Controls->m_ODFRenderWidget->setVisible(false);
       m_Controls->m_OdfBox->setVisible(false);
       m_Controls->m_OverviewBox->setVisible(false);
       return;
     }
 
     // restore the input image label ( needed in case the last run resulted into an exception )
     m_Controls->m_InputImageLabel->setText(m_ImageNode->GetName().c_str());
 
     // ODF Normalization Property
     mitk::OdfNormalizationMethodProperty* nmp = dynamic_cast<mitk::OdfNormalizationMethodProperty*>(m_ImageNode->GetProperty( "Normalization" ));
     if(nmp)
       m_OdfNormalization = nmp->GetNormalization();
 
     m_TemplateOdf = itk::OrientationDistributionFunction<float,QBALL_ODFSIZE>::GetBaseMesh();
     m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
     m_OdfTransform->Identity();
     m_OdfVals = vtkSmartPointer<vtkDoubleArray>::New();
     m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
     itk::OrientationDistributionFunction<double, QBALL_ODFSIZE> odf;
 
     mitk::Point3D world = m_MultiWidget->GetCrossPosition();
     mitk::Point3D index;
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
     unsigned int *img_dimension = img->GetDimensions();
-    img->GetTimeSlicedGeometry()->WorldToIndex(world, index);
+    img->GetGeometry()->WorldToIndex(world, index);
 
     float sum = 0;
     float max = itk::NumericTraits<float>::NonpositiveMin();
     float min = itk::NumericTraits<float>::max();
     QString values;
     QString overviewText;
 
     // check if dynamic_cast successfull and if the crosshair position is inside of the geometry of the ODF data
     // otherwise possible crash for a scenario with multiple nodes
     if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()) && ( m_ImageNode->GetData()->GetGeometry()->IsInside(world) ) )
     {
       m_Controls->m_ODFRenderWidget->setVisible(true);
       m_Controls->m_OdfBox->setVisible(true);
 
       try
       {
         mitk::QBallImage* qball_image = dynamic_cast< mitk::QBallImage* >( m_ImageNode->GetData() );
 
         // get access to the qball image data with explicitely allowing exceptions if memory locked
         mitk::ImageReadAccessor readAccess( qball_image, qball_image->GetVolumeData(0), mitk::ImageAccessorBase::ExceptionIfLocked );
         const float* qball_cPtr = static_cast< const float*>(readAccess.GetData());
 
         OdfVectorImgType::IndexType ind;
         ind[0] = (int)(index[0]+0.5);
         ind[1] = (int)(index[1]+0.5);
         ind[2] = (int)(index[2]+0.5);
 
         // pixel size = QBALL_ODFSIZE
         // position offset = standard offset
         unsigned int offset_to_data = QBALL_ODFSIZE * (ind[2] * img_dimension[1] * img_dimension[0] + ind[1] * img_dimension[0] + ind[0]);
         const float *pixel_data = qball_cPtr + offset_to_data;
 
         for (int i=0; i<QBALL_ODFSIZE; i++)
         {
           float val = pixel_data[i];
           odf.SetNthComponent(i, val);
           values += QString::number(i)+": "+QString::number(val)+"\n";
           sum += val;
           if (val>max)
             max = val;
           if (val<min)
             min = val;
         }
         float mean = sum/QBALL_ODFSIZE;
 
         QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
         overviewText += "Coordinates: "+pos+"\n";
         overviewText += "GFA: "+QString::number(odf.GetGeneralizedFractionalAnisotropy())+"\n";
         overviewText += "Sum: "+QString::number(sum)+"\n";
         overviewText += "Mean: "+QString::number(mean)+"\n";
         overviewText += "Min: "+QString::number(min)+"\n";
         overviewText += "Max: "+QString::number(max)+"\n";
         vnl_vector_fixed<double, 3> pd = odf.GetDirection(odf.GetPrincipleDiffusionDirection());
         overviewText += "Main Diffusion:\n     "+QString::number(pd[0])+"\n     "+QString::number(pd[1])+"\n     "+QString::number(pd[2])+"\n";
 
         m_Controls->m_OdfValuesTextEdit->setText(values);
         m_Controls->m_OverviewTextEdit->setVisible(true);
       }
       catch( mitk::Exception &e )
       {
         MITK_WARN << "LOCKED : " << e.what();
         m_Controls->m_ODFRenderWidget->setVisible(false);
         m_Controls->m_OdfBox->setVisible(false);
         m_Controls->m_OverviewTextEdit->setVisible(false);
 
         // reset the selection
         m_Controls->m_InputImageLabel->setText("<font color='green'>Click image to restore rendering!</font>");
       }
     }
     else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()))
     {
       m_Controls->m_ODFRenderWidget->setVisible(true);
       m_Controls->m_OdfBox->setVisible(false);
 
 
       mitk::TensorImage* qball_image = dynamic_cast< mitk::TensorImage*>(m_ImageNode->GetData());
 
       // pixel access block
       try
       {
         // get access to the qball image data with explicitely allowing exceptions if memory locked
         mitk::ImageReadAccessor readAccess( qball_image, qball_image->GetVolumeData(0), mitk::ImageAccessorBase::ExceptionIfLocked );
         const float* qball_cPtr = static_cast< const float*>(readAccess.GetData());
 
         TensorImageType::IndexType ind;
         ind[0] = (int)(index[0]+0.5);
         ind[1] = (int)(index[1]+0.5);
         ind[2] = (int)(index[2]+0.5);
 
         // 6 - tensorsize
         // remaining computation - standard offset
         unsigned int offset_to_data = 6 * (ind[2] * img_dimension[1] * img_dimension[0] + ind[1] * img_dimension[0] + ind[0]);
         const float *pixel_data = qball_cPtr + offset_to_data;
 
         float tensorelems[6] = {
           *(pixel_data    ),
           *(pixel_data + 1),
           *(pixel_data + 2),
           *(pixel_data + 3),
           *(pixel_data + 4),
           *(pixel_data + 5),
         };
 
         itk::DiffusionTensor3D<float> tensor(tensorelems);
         odf.InitFromTensor(tensor);
 
         /** Array of eigen-values. */
         typedef itk::FixedArray<float, 3> EigenValuesArrayType;
         /** Matrix of eigen-vectors. */
         typedef itk::Matrix<float, 3, 3> MatrixType;
         typedef itk::Matrix<float, 3, 3> EigenVectorsMatrixType;
 
         EigenValuesArrayType eigenValues;
         EigenVectorsMatrixType eigenVectors;
 
         QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
         overviewText += "Coordinates: "+pos+"\n";
         overviewText += "FA: "+QString::number(tensor.GetFractionalAnisotropy())+"\n";
         overviewText += "RA: "+QString::number(tensor.GetRelativeAnisotropy())+"\n";
         overviewText += "Trace: "+QString::number(tensor.GetTrace())+"\n";
         tensor.ComputeEigenAnalysis(eigenValues,eigenVectors);
         overviewText += "Eigenvalues:\n     "+QString::number(eigenValues[2])+"\n     "+QString::number(eigenValues[1])+"\n     "+QString::number(eigenValues[0])+"\n";
         overviewText += "Main Diffusion:\n     "+QString::number(eigenVectors[0][0])+"\n     "+QString::number(eigenVectors[1][0])+"\n     "+QString::number(eigenVectors[2][0])+"\n";
         overviewText += "Values:\n     "+QString::number(tensorelems[0])+"\n     "+QString::number(tensorelems[1])+"\n     "+QString::number(tensorelems[2])+"\n     "+QString::number(tensorelems[3])+"\n     "+QString::number(tensorelems[4])+"\n     "+QString::number(tensorelems[5])+"\n     "+"\n";
         m_Controls->m_OverviewTextEdit->setVisible(true);
       }
       // end pixel access block
       catch(mitk::Exception &e )
       {
         MITK_WARN << "LOCKED : " << e.what();
         m_Controls->m_ODFRenderWidget->setVisible(false);
         m_Controls->m_OdfBox->setVisible(false);
         m_Controls->m_OverviewTextEdit->setVisible(false);
 
         // reset the selection
         m_Controls->m_InputImageLabel->setText("<font color='green'>Click image to restore rendering!</font>");
       }
     }
     else
     {
       m_Controls->m_ODFRenderWidget->setVisible(false);
       m_Controls->m_OdfBox->setVisible(false);
       overviewText += "Please reinit image geometry.\n";
     }
 
     // proceed only if the render widget is visible which indicates that the
     // predecessing computations were successfull
     if( m_Controls->m_ODFRenderWidget->isVisible() )
     {
       m_Controls->m_ODFDetailsWidget->SetParameters(odf);
 
       switch(m_OdfNormalization)
       {
       case 0:
         odf = odf.MinMaxNormalize();
         break;
       case 1:
         odf = odf.MaxNormalize();
         break;
       case 2:
         odf = odf.MaxNormalize();
         break;
       default:
         odf = odf.MinMaxNormalize();
       }
 
       m_Controls->m_ODFRenderWidget->GenerateODF(odf);
       m_Controls->m_OverviewTextEdit->setText(overviewText.toStdString().c_str());
     }
   }
   catch(...)
   {
     QMessageBox::critical(0, "Error", "Data could not be analyzed. The image might be corrupted.");
   }
 }
 
 void QmitkODFDetailsView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
   UpdateOdf();
 }
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
index 2ebc92ca6a..f0b21f3a28 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
@@ -1,293 +1,293 @@
 /*===================================================================
 
 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 "QmitkDTIAtlasAppIntroPart.h"
 
 #include "mitkNodePredicateDataType.h"
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbench.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryWorkbenchPreferenceConstants.h>
 #include <berryIPreferences.h>
 #include <berryIEditorReference.h>
 
 #include <mitkLogMacros.h>
 
 #include <QLabel>
 #include <QMessageBox>
 #include <QtCore/qconfig.h>
 #ifdef QT_WEBKIT
 #include <QWebView>
 #include <QWebPage>
 #endif
 #include <QString>
 #include <QStringList>
 #include <QRegExp>
 #include <QChar>
 #include <QByteArray>
 #include <QDesktopServices>
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkStdMultiWidgetEditor.h"
 #include "QmitkDTIAtlasAppApplicationPlugin.h"
 #include "mitkDataStorageEditorInput.h"
 
 #include "mitkBaseDataIOFactory.h"
 #include "mitkSceneIO.h"
 #include "mitkProgressBar.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 
 QmitkDTIAtlasAppIntroPart::QmitkDTIAtlasAppIntroPart()
   : m_Controls(NULL)
 {
   berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
   workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
   workbenchPrefs->Flush();
 }
 
 QmitkDTIAtlasAppIntroPart::~QmitkDTIAtlasAppIntroPart()
 {
   // if the workbench is not closing (that means, welcome screen was closed explicitly), set "Show_intro" false
   if (!this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
   {
     berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
     workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, false);
     workbenchPrefs->Flush();
   }
   else
   {
     berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
     workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
     workbenchPrefs->Flush();
   }
 
   // if workbench is not closing (Just welcome screen closing), open last used perspective
   if (this->GetIntroSite()->GetPage()->GetPerspective()->GetId()
     == "org.mitk.dtiatlasapp.perspectives.welcome" && !this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
     {
     berry::IPerspectiveDescriptor::Pointer perspective = this->GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->GetPerspectiveRegistry()->FindPerspectiveWithId("org.mitk.dtiatlasapp.perspectives.dtiatlasapp");
     if (perspective)
     {
       this->GetIntroSite()->GetPage()->SetPerspective(perspective);
     }
   }
 
 }
 
 
 void QmitkDTIAtlasAppIntroPart::CreateQtPartControl(QWidget* parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkWelcomeScreenViewControls;
     m_Controls->setupUi(parent);
 #ifdef QT_WEBKIT
 
     // create a QWebView as well as a QWebPage and QWebFrame within the QWebview
     m_view = new QWebView(parent);
     m_view->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
 
     QUrl urlQtResource(QString("qrc:/org.mitk.gui.qt.welcomescreen/mitkdtiatlasappwelcomeview.html"),  QUrl::TolerantMode );
     m_view->load( urlQtResource );
 
     // adds the webview as a widget
     parent->layout()->addWidget(m_view);
     this->CreateConnections();
 #else
     parent->layout()->addWidget(new QLabel("<h1><center>Please install Qt with the WebKit option to see cool pictures!</center></h1>"));
 #endif
   }
 }
 
 #ifdef QT_WEBKIT
 void QmitkDTIAtlasAppIntroPart::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_view->page()), SIGNAL(linkClicked(const QUrl& )), this, SLOT(DelegateMeTo(const QUrl& )) );
   }
 }
 
 
 void QmitkDTIAtlasAppIntroPart::DelegateMeTo(const QUrl& showMeNext)
 {
   QString scheme          = showMeNext.scheme();
   QByteArray urlHostname  = showMeNext.encodedHost();
   QByteArray urlPath      = showMeNext.encodedPath();
   QByteArray dataset      = showMeNext.encodedQueryItemValue("dataset");
   QByteArray clear        = showMeNext.encodedQueryItemValue("clear");
 
   if (scheme.isEmpty()) MITK_INFO << " empty scheme of the to be delegated link" ;
 
   // if the scheme is set to mitk, it is to be tested which action should be applied
   if (scheme.contains(QString("mitk")) )
   {
     if(urlPath.isEmpty() ) MITK_INFO << " mitk path is empty " ;
 
     // searching for the perspective keyword within the host name
     if(urlHostname.contains(QByteArray("perspectives")) )
     {
       // the simplified method removes every whitespace
       // ( whitespace means any character for which the standard C++ isspace() method returns true)
       urlPath = urlPath.simplified();
       QString tmpPerspectiveId(urlPath.data());
       tmpPerspectiveId.replace(QString("/"), QString("") );
       std::string perspectiveId  = tmpPerspectiveId.toStdString();
 
       // is working fine as long as the perspective id is valid, if not the application crashes
       GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->ShowPerspective(perspectiveId, GetIntroSite()->GetWorkbenchWindow() );
 
       mitk::DataStorageEditorInput::Pointer editorInput;
       editorInput = new mitk::DataStorageEditorInput();
       berry::IEditorPart::Pointer editor = GetIntroSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID);
 
 
       QmitkStdMultiWidgetEditor::Pointer multiWidgetEditor;
       mitk::DataStorage::Pointer dataStorage;
 
       if (editor.Cast<QmitkStdMultiWidgetEditor>().IsNull())
       {
         editorInput = new mitk::DataStorageEditorInput();
         dataStorage = editorInput->GetDataStorageReference()->GetDataStorage();
       }
       else
       {
         multiWidgetEditor = editor.Cast<QmitkStdMultiWidgetEditor>();
         multiWidgetEditor->GetStdMultiWidget()->RequestUpdate();
         dataStorage = multiWidgetEditor->GetEditorInput().Cast<mitk::DataStorageEditorInput>()->GetDataStorageReference()->GetDataStorage();
       }
 
       bool dsmodified = false;
 
       QString *fileName = new QString(dataset.data());
 
       if ( fileName->right(5) == ".mitk" )
       {
         mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
 
         bool clearDataStorageFirst(false);
         QString *sClear = new QString(clear.data());
         if ( sClear->right(4) == "true" )
         {
           clearDataStorageFirst = true;
         }
 
         mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
         dataStorage = sceneIO->LoadScene( fileName->toLocal8Bit().constData(), dataStorage, clearDataStorageFirst );
         dsmodified = true;
         mitk::ProgressBar::GetInstance()->Progress(2);
       }
       else
       {
         mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
         try
         {
           nodeReader->SetFileName(fileName->toLocal8Bit().data());
           nodeReader->Update();
           for ( unsigned int i = 0 ; i < nodeReader->GetNumberOfOutputs( ); ++i )
           {
             mitk::DataNode::Pointer node;
             node = nodeReader->GetOutput(i);
             if ( node->GetData() != NULL )
             {
               dataStorage->Add(node);
               dsmodified = true;
             }
           }
         }
         catch(...)
         {
           MITK_INFO << "Could not open file!";
         }
       }
 
 
 
       if(dataStorage.IsNotNull() && dsmodified)
       {
         // get all nodes that have not set "includeInBoundingBox" to false
         mitk::NodePredicateNot::Pointer pred
             = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
                                                                            , mitk::BoolProperty::New(false)));
 
         mitk::DataStorage::SetOfObjects::ConstPointer rs = dataStorage->GetSubset(pred);
 
         if(rs->Size() > 0)
         {
           // calculate bounding geometry of these nodes
-          mitk::TimeSlicedGeometry::Pointer bounds = dataStorage->ComputeBoundingGeometry3D(rs);
+          mitk::TimeGeometry::Pointer bounds = dataStorage->ComputeBoundingGeometry3D(rs);
           // initialize the views to the bounding geometry
           mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
         }
       }
 
 
 
 
 
     }
     // searching for the load
     if(urlHostname.contains(QByteArray("perspectives")) )
     {
       // the simplified method removes every whitespace
       // ( whitespace means any character for which the standard C++ isspace() method returns true)
       urlPath = urlPath.simplified();
       QString tmpPerspectiveId(urlPath.data());
       tmpPerspectiveId.replace(QString("/"), QString("") );
       std::string perspectiveId  = tmpPerspectiveId.toStdString();
 
       // is working fine as long as the perspective id is valid, if not the application crashes
       GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->ShowPerspective(perspectiveId, GetIntroSite()->GetWorkbenchWindow() );
 
       mitk::DataStorageEditorInput::Pointer editorInput;
       editorInput = new mitk::DataStorageEditorInput();
       GetIntroSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID);
     }
     else
     {
       MITK_INFO << "Unkown mitk action keyword (see documentation for mitk links)" ;
     }
   }
   // if the scheme is set to http, by default no action is performed, if an external webpage needs to be
   // shown it should be implemented below
   else if (scheme.contains(QString("http")) )
   {
     QDesktopServices::openUrl(showMeNext);
 //    m_view->load( ) ;
   }
   else if(scheme.contains("qrc"))
   {
     m_view->load(showMeNext);
   }
 
 }
 
 #endif
 
 void QmitkDTIAtlasAppIntroPart::StandbyStateChanged(bool standby)
 {
 
 }
 
 
 void QmitkDTIAtlasAppIntroPart::SetFocus()
 {
 
 }
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
index 7c98e36e71..2658538c68 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
@@ -1,950 +1,950 @@
 /*===================================================================
 
 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 "QmitkNavigationButtonsView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 #include "mitkModuleRegistry.h"
 
 #include "mitkDiffusionImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 
 #include "mitkGlobalInteraction.h"
 
 #include "mitkGeometry2D.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include "itkTractsToProbabilityImageFilter.h"
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 
 const std::string QmitkNavigationButtonsView::VIEW_ID = "org.mitk.views.NavigationButtonsview";
 
 using namespace berry;
 
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
 {
 }
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView(const QmitkNavigationButtonsView& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkNavigationButtonsView::~QmitkNavigationButtonsView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 
 
 void QmitkNavigationButtonsView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationButtonsViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
   }
 }
 
 
 void QmitkNavigationButtonsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkNavigationButtonsView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkNavigationButtonsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
   }
 }
 
 void QmitkNavigationButtonsView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkNavigationButtonsView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkNavigationButtonsView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkNavigationButtonsView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
 
 mitk::DataStorage::SetOfObjects::Pointer
     QmitkNavigationButtonsView::ActiveSet(std::string classname)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
         mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
     i != m_CurrentSelection->End();
     ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
         if(QString(classname.c_str()).compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     return set;
   }
 
   return 0;
 }
 
 void QmitkNavigationButtonsView::SetBoolProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, bool value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetBoolProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetIntProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, int value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetFloatProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, float value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetFloatProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetLevelWindowProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::LevelWindow value)
 {
   if(set.IsNotNull())
   {
 
     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), prop);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetEnumProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::EnumerationProperty::Pointer value)
 {
   if(set.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::DisplayIndexChanged(int dispIndex)
 {
 
   QString label = "Channel %1";
   label = label.arg(dispIndex);
   m_Controls->label_channel->setText(label);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
 
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
       ++itemiter;
     }
 
     //m_MultiWidget->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::Reinit()
 {
   if (m_CurrentSelection)
   {
     mitk::DataNodeObject::Pointer nodeObj =
         m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
       mitk::RenderingManager::GetInstance()->InitializeViews(
-          basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+          basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkNavigationButtonsView::TextIntON()
 {
   if(m_TexIsOn)
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
   }
   else
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("QBallImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("Image");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   m_TexIsOn = !m_TexIsOn;
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_S()
 {
   if(m_GlyIsOn_S)
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyOFF_S);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyON_S);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   m_GlyIsOn_S = !m_GlyIsOn_S;
 
   VisibleOdfsON(0);
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_T()
 {
   if(m_GlyIsOn_T)
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyOFF_T);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyON_T);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   m_GlyIsOn_T = !m_GlyIsOn_T;
 
   VisibleOdfsON(1);
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_C()
 {
   if(m_GlyIsOn_C)
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyOFF_C);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyON_C);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   m_GlyIsOn_C = !m_GlyIsOn_C;
 
   VisibleOdfsON(2);
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON(int view)
 {
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   set = ActiveSet("TensorImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
   case 0:
     normMeth->SetNormalizationToMinMax();
     break;
   case 1:
     normMeth->SetNormalizationToMax();
     break;
   case 2:
     normMeth->SetNormalizationToNone();
     break;
   case 3:
     normMeth->SetNormalizationToGlobalMax();
     break;
   default:
     normMeth->SetNormalizationToMinMax();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ScalingFactorChanged(double scalingFactor)
 {
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
   case 0:
     scaleBy->SetScaleByNothing();
     break;
   case 1:
     scaleBy->SetScaleByGFA();
     //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
   case 2:
     scaleBy->SetScaleByPrincipalCurvature();
     // commented in for SPIE paper, Principle curvature scaling
     //m_Controls->params_frame->setVisible(true);
     break;
 #endif
   default:
     scaleBy->SetScaleByNothing();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::IndexParam1Changed(double param1)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkNavigationButtonsView::IndexParam2Changed(double param2)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkNavigationButtonsView::OpacityChanged(double l, double u)
 {
   mitk::LevelWindow olw;
   olw.SetRangeMinMax(l*255, u*255);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("TensorImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("Image");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible(
       m_Controls->m_ScalingCheckbox->isChecked());
 }
 
 
 void QmitkNavigationButtonsView::BundleRepresentationWire()
 {
   if(m_SelectedNode)
   {
     int width = m_Controls->m_LineWidth->value();
     m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::BundleRepresentationTube()
 {
   if(m_SelectedNode)
   {
     float radius = m_Controls->m_TubeRadius->value() / 100.0;
     m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::BundleRepresentationColor()
 {
   if(m_SelectedNode)
   {
     QColor color = QColorDialog::getColor();
 
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.blue()));
     styleSheet.append(")");
     m_Controls->m_Color->setStyleSheet(styleSheet);
 
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(14));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure)
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       QmitkRenderWindow* RenderWindow1 =
           this->GetActiveStdMultiWidget()->GetRenderWindow1();
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
         PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       QmitkRenderWindow* RenderWindow2 =
           this->GetActiveStdMultiWidget()->GetRenderWindow2();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       QmitkRenderWindow* RenderWindow3 =
           this->GetActiveStdMultiWidget()->GetRenderWindow3();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       QmitkRenderWindow* RenderWindow4 =
           this->GetActiveStdMultiWidget()->GetRenderWindow4();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry
           * _PlaneGeometry =
           dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
         RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
         RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
         RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       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;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
             centerP, _PlaneGeometry->GetNormal());
         selectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
             centerP);
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
 
   }
 }
 
 void QmitkNavigationButtonsView::SetInteractor()
 {
   typedef std::vector<mitk::DataNode*> Container;
   Container _NodeSet = this->GetDataManagerSelection();
   mitk::DataNode* node = 0;
   mitk::FiberBundle* bundle = 0;
   mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   // finally add all nodes to the model
   for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
     ; it++)
     {
     node = const_cast<mitk::DataNode*>(*it);
     bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
     if(bundle)
     {
       bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
       if(bundleInteractor.IsNotNull())
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
       if(!m_Controls->m_Crosshair->isChecked())
       {
         m_Controls->m_Crosshair->setChecked(false);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
         m_CurrentPickingNode = 0;
       }
       else
       {
         m_Controls->m_Crosshair->setChecked(true);
         bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
         mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
         m_CurrentPickingNode = node;
       }
 
     }
   }
 
 }
 
 void QmitkNavigationButtonsView::PFWidth(int w)
 {
 
   double width = w/10.0;
   m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QString label = "Width %1";
   label = label.arg(width);
   m_Controls->label_pfwidth->setText(label);
 
 }
 
 void QmitkNavigationButtonsView::PFColor()
 {
 
   QColor color = QColorDialog::getColor();
 
   m_Controls->m_PFColor->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
 
 //  m_SelectedNode->SetProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationButtonsView::PFColor3D()
 {
 
   QColor color = QColorDialog::getColor();
 
   m_Controls->m_PFColor3D->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor3D->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationButtonsView::Heatmap()
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     if(!bundle)
       return;
 
     ///////////////////////////////
     // Generate unsigned char Image
     typedef unsigned char OutPixType2;
 
     // run generator
     typedef itk::Image< float, 3 >            WMPImageType;
     typedef itk::TractsToProbabilityImageFilter<WMPImageType,
         OutPixType2> ImageGeneratorType2;
     ImageGeneratorType2::Pointer generator = ImageGeneratorType2::New();
     //generator->SetInput(NULL);
     generator->SetFiberBundle(bundle);
     generator->SetInvertImage(false);
     generator->SetUpsamplingFactor(2);
     generator->SetBinaryEnvelope(false);
     generator->Update();
 
     // get result
     typedef itk::Image<OutPixType2,3> OutType2;
     OutType2::Pointer outImg = generator->GetOutput();
 
     mitk::Image::Pointer img2 = mitk::Image::New();
     img2->InitializeByItk(outImg.GetPointer());
     img2->SetVolume(outImg->GetBufferPointer());
 
     // to datastorage
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img2);
     QString name(m_SelectedNode->GetName().c_str());
     name += "_heatmap";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
 
     GetDataStorage()->Add(node);
   }
 }
 
 void QmitkNavigationButtonsView::LineWidthChanged(int w)
 {
   m_SelectedNode->SetIntProperty("LineWidth", w);
 
   QString label = "Width %1";
   label = label.arg(w);
   m_Controls->label_linewidth->setText(label);
 }
 
 void QmitkNavigationButtonsView::TubeRadiusChanged(int r)
 {
   m_SelectedNode->SetFloatProperty("TubeRadius", (float) r / 100.0);
 
   QString label = "Radius %1";
   label = label.arg(r / 100.0);
   m_Controls->label_tuberadius->setText(label);
 }
 
 void QmitkNavigationButtonsView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
    GetSite()->GetWorkbenchWindow(), false);
 }
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp
index d819524251..88f58189cb 100644
--- a/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp
@@ -1,305 +1,305 @@
 /*===================================================================
 
 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 "QmitkSimpleExampleView.h"
 
 #include "mitkNodePredicateDataType.h"
 
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include <QMessageBox>
 
 #include <mitkMovieGenerator.h>
 #include "mitkNodePredicateProperty.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkProperties.h"
 #include <QmitkStepperAdapter.h>
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QDir>
 
 
 #include <vtkRenderWindow.h>
 #include "vtkImageWriter.h"
 #include "vtkPNGWriter.h"
 #include "vtkJPEGWriter.h"
 #include "vtkRenderLargeImage.h"
 
 const std::string QmitkSimpleExampleView::VIEW_ID = "org.mitk.views.simpleexample";
 
 QmitkSimpleExampleView::QmitkSimpleExampleView()
 : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
   m_NavigatorsInitialized(false)
 {
 }
 
 QmitkSimpleExampleView::QmitkSimpleExampleView(const QmitkSimpleExampleView& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkSimpleExampleView::~QmitkSimpleExampleView()
 {
 }
 
 void QmitkSimpleExampleView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkSimpleExampleViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkSimpleExampleView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 
   new QmitkStepperAdapter(m_Controls->sliceNavigatorAxial, m_MultiWidget->mitkWidget1->GetSliceNavigationController()->GetSlice(), "sliceNavigatorAxialFromSimpleExample");
   new QmitkStepperAdapter(m_Controls->sliceNavigatorSagittal, m_MultiWidget->mitkWidget2->GetSliceNavigationController()->GetSlice(), "sliceNavigatorSagittalFromSimpleExample");
   new QmitkStepperAdapter(m_Controls->sliceNavigatorFrontal, m_MultiWidget->mitkWidget3->GetSliceNavigationController()->GetSlice(), "sliceNavigatorFrontalFromSimpleExample");
   new QmitkStepperAdapter(m_Controls->sliceNavigatorTime, m_MultiWidget->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromSimpleExample");
   new QmitkStepperAdapter(m_Controls->movieNavigatorTime, m_MultiWidget->GetTimeNavigationController()->GetTime(), "movieNavigatorTimeFromSimpleExample");
 }
 
 void QmitkSimpleExampleView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkSimpleExampleView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect(m_Controls->stereoSelect, SIGNAL(activated(int)), this, SLOT(stereoSelectionChanged(int)) );
     connect(m_Controls->reInitializeNavigatorsButton, SIGNAL(clicked()), this, SLOT(initNavigators()) );
     connect(m_Controls->genMovieButton, SIGNAL(clicked()), this, SLOT(generateMovie()) );
     connect(m_Controls->m_RenderWindow1Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow1Clicked()) );
     connect(m_Controls->m_RenderWindow2Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow2Clicked()) );
     connect(m_Controls->m_RenderWindow3Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow3Clicked()) );
     connect(m_Controls->m_RenderWindow4Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow4Clicked()) );
     connect(m_Controls->m_TakeScreenshotBtn, SIGNAL(clicked()), this, SLOT(OnTakeScreenshot()) );
     connect(m_Controls->m_TakeHighResScreenShotBtn, SIGNAL(clicked()), this, SLOT(OnTakeHighResolutionScreenshot()) );
   }
 }
 
 void QmitkSimpleExampleView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkSimpleExampleView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkSimpleExampleView::initNavigators()
 {
   /* get all nodes that have not set "includeInBoundingBox" to false */
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   /* calculate bounding geometry of these nodes */
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs);
+  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs);
   /* initialize the views to the bounding geometry */
   m_NavigatorsInitialized = mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
   //m_NavigatorsInitialized = mitk::RenderingManager::GetInstance()->InitializeViews(GetDefaultDataStorage());
 }
 
 void QmitkSimpleExampleView::generateMovie()
 {
   QmitkRenderWindow* movieRenderWindow = GetMovieRenderWindow();
   //mitk::Stepper::Pointer stepper = multiWidget->mitkWidget1->GetSliceNavigationController()->GetSlice();
   mitk::Stepper::Pointer stepper = movieRenderWindow->GetSliceNavigationController()->GetSlice();
   mitk::MovieGenerator::Pointer movieGenerator = mitk::MovieGenerator::New();
   if (movieGenerator.IsNotNull()) {
     movieGenerator->SetStepper( stepper );
     movieGenerator->SetRenderer( mitk::BaseRenderer::GetInstance(movieRenderWindow->GetRenderWindow()) );
 
     QString movieFileName = QFileDialog::getSaveFileName(0, "Choose a file name", QString(), "Movie (*.avi)");
     if (!movieFileName.isEmpty()) {
       movieGenerator->SetFileName( movieFileName.toStdString().c_str() );
       movieGenerator->WriteMovie();
     }
   }
 }
 
 void QmitkSimpleExampleView::stereoSelectionChanged( int id )
 {
   /* From vtkRenderWindow.h tells us about stereo rendering:
   Set/Get what type of stereo rendering to use. CrystalEyes mode uses frame-sequential capabilities available in OpenGL to drive LCD shutter glasses and stereo projectors. RedBlue mode is a simple type of stereo for use with red-blue glasses. Anaglyph mode is a superset of RedBlue mode, but the color output channels can be configured using the AnaglyphColorMask and the color of the original image can be (somewhat maintained using AnaglyphColorSaturation; the default colors for Anaglyph mode is red-cyan. Interlaced stereo  mode produces a composite image where horizontal lines alternate between left and right views. StereoLeft and StereoRight modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.
   */
 
   vtkRenderWindow * vtkrenderwindow = m_MultiWidget->mitkWidget4->GetRenderWindow();
 
   // note: foreground vtkRenderers (at least the department logo renderer) produce errors in stereoscopic visualization.
   // Therefore, we disable the logo visualization during stereo rendering.
   switch(id)
   {
   case 0:
     vtkrenderwindow->StereoRenderOff();
     break;
   case 1:
     vtkrenderwindow->SetStereoTypeToRedBlue();
     vtkrenderwindow->StereoRenderOn();
     m_MultiWidget->DisableDepartmentLogo();
     break;
   case 2:
     vtkrenderwindow->SetStereoTypeToDresden();
     vtkrenderwindow->StereoRenderOn();
     m_MultiWidget->DisableDepartmentLogo();
     break;
   }
 
 
   mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget4->GetRenderWindow())->SetMapperID(2);
   m_MultiWidget->RequestUpdate();
 }
 
 QmitkRenderWindow* QmitkSimpleExampleView::GetMovieRenderWindow()
 {
   //check which RenderWindow should be used to generate the movie, e.g. which button is toggled
    if(m_Controls->m_RenderWindow1Button->isChecked())
    {
     return m_MultiWidget->mitkWidget1;
    }
    else if(m_Controls->m_RenderWindow2Button->isChecked())
    {
      return m_MultiWidget->mitkWidget2;
    }
    else if(m_Controls->m_RenderWindow3Button->isChecked())
    {
      return m_MultiWidget->mitkWidget3;
    }
    else if(m_Controls->m_RenderWindow4Button->isChecked())
    {
      return m_MultiWidget->mitkWidget4;
    }
    else //as default take widget1
    {
      return m_MultiWidget->mitkWidget1;
    }
 
 }
 
 void QmitkSimpleExampleView::OnRenderWindow1Clicked()
 {
   m_Controls->m_RenderWindow2Button->setChecked(false);
   m_Controls->m_RenderWindow3Button->setChecked(false);
   m_Controls->m_RenderWindow4Button->setChecked(false);
 }
 void QmitkSimpleExampleView::OnRenderWindow2Clicked()
 {
   m_Controls->m_RenderWindow1Button->setChecked(false);
   m_Controls->m_RenderWindow3Button->setChecked(false);
   m_Controls->m_RenderWindow4Button->setChecked(false);
 }
 void QmitkSimpleExampleView::OnRenderWindow3Clicked()
 {
   m_Controls->m_RenderWindow2Button->setChecked(false);
   m_Controls->m_RenderWindow1Button->setChecked(false);
   m_Controls->m_RenderWindow4Button->setChecked(false);
 }
 void QmitkSimpleExampleView::OnRenderWindow4Clicked()
 {
   m_Controls->m_RenderWindow2Button->setChecked(false);
   m_Controls->m_RenderWindow3Button->setChecked(false);
   m_Controls->m_RenderWindow1Button->setChecked(false);
 }
 
 
 void QmitkSimpleExampleView::OnTakeHighResolutionScreenshot()
 {
   QString fileName = QFileDialog::getSaveFileName(NULL, "Save screenshot to...", QDir::currentPath(), "JPEG file (*.jpg);;PNG file (*.png)");
 
   // only works correctly for 3D RenderWindow
   vtkRenderer* renderer = m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer();
   if (renderer == NULL)
     return;
   this->TakeScreenshot(renderer, 4, fileName);
 }
 
 void QmitkSimpleExampleView::OnTakeScreenshot()
 {
   QString fileName = QFileDialog::getSaveFileName(NULL, "Save screenshot to...", QDir::currentPath(), "JPEG file (*.jpg);;PNG file (*.png)");
 
   QmitkRenderWindow* renWin = this->GetMovieRenderWindow();
   if (renWin == NULL)
     return;
 
   vtkRenderer* renderer = renWin->GetRenderer()->GetVtkRenderer();
   if (renderer == NULL)
     return;
   this->TakeScreenshot(renderer, 1, fileName);
 }
 
 
 void QmitkSimpleExampleView::TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName)
 {
   if ((renderer == NULL) ||(magnificationFactor < 1) || fileName.isEmpty())
     return;
 
   bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
   renderer->GetRenderWindow()->DoubleBufferOff();
 
   vtkImageWriter* fileWriter;
 
   QFileInfo fi(fileName);
   QString suffix = fi.suffix();
   if (suffix.compare("png", Qt::CaseInsensitive) == 0)
   {
     fileWriter = vtkPNGWriter::New();
   }
   else  // default is jpeg
   {
     vtkJPEGWriter* w = vtkJPEGWriter::New();
     w->SetQuality(100);
     w->ProgressiveOff();
     fileWriter = w;
   }
   vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
   magnifier->SetInput(renderer);
   magnifier->SetMagnification(magnificationFactor);
   //magnifier->Update();
   fileWriter->SetInput(magnifier->GetOutput());
   fileWriter->SetFileName(fileName.toLatin1());
 
   // vtkRenderLargeImage has problems with different layers, therefore we have to
   // temporarily deactivate all other layers.
   // we set the background to white, because it is nicer than black...
   double oldBackground[3];
   renderer->GetBackground(oldBackground);
   double white[] = {1.0, 1.0, 1.0};
   renderer->SetBackground(white);
   m_MultiWidget->DisableColoredRectangles();
   m_MultiWidget->DisableDepartmentLogo();
   m_MultiWidget->DisableGradientBackground();
 
   fileWriter->Write();
   fileWriter->Delete();
 
   m_MultiWidget->EnableColoredRectangles();
   m_MultiWidget->EnableDepartmentLogo();
   m_MultiWidget->EnableGradientBackground();
   renderer->SetBackground(oldBackground);
 
   renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
 }
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp
index 58ceaaa61f..9b92b43e5f 100644
--- a/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp
@@ -1,193 +1,193 @@
 /*===================================================================
 
 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 "QmitkViewInitializationView.h"
 
 #include "mitkNodePredicateDataType.h"
 
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "mitkFocusManager.h"
 #include "mitkGlobalInteraction.h"
 #include "itkCommand.h"
 
 
 #include <QMessageBox>
 
 
 
 const std::string QmitkViewInitializationView::VIEW_ID = "org.mitk.views.viewinitialization";
 
 QmitkViewInitializationView::QmitkViewInitializationView()
 : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL)
 {
   m_CommandTag = 0;
 }
 
 QmitkViewInitializationView::~QmitkViewInitializationView()
 {
 }
 
 void QmitkViewInitializationView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkViewInitializationViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkViewInitializationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkViewInitializationView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkViewInitializationView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->pbApply), SIGNAL(clicked()),(QObject*) this, SLOT(OnApply()) );
     connect( (QObject*)(m_Controls->pbReset), SIGNAL(clicked()),(QObject*) this, SLOT(OnResetAll()) );
   }
 }
 
 void QmitkViewInitializationView::Activated()
 {
   //init render window selector (List Widget)
   this->InitRenderWindowSelector();
   QmitkFunctionality::Activated();
 }
 
 void QmitkViewInitializationView::Deactivated()
 {
   mitk::FocusManager* fm = mitk::GlobalInteraction::GetInstance()->GetFocusManager();
   fm->RemoveObserver(m_CommandTag);
   QmitkFunctionality::Deactivated();
 }
 
 
 void QmitkViewInitializationView::OnApply()
 {
   mitk::SliceNavigationController::ViewDirection viewDirection( mitk::SliceNavigationController::Axial );
   if( m_Controls->rbAxial->isChecked() )
     viewDirection = mitk::SliceNavigationController::Axial;
 
   else if( m_Controls->rbFrontal->isChecked())
     viewDirection = mitk::SliceNavigationController::Frontal;
 
   else if( m_Controls->rbSagittal->isChecked() )
     viewDirection = mitk::SliceNavigationController::Sagittal;
 
   vtkRenderWindow* renderwindow = this->GetSelectedRenderWindow();
   if(renderwindow != NULL)
   {
     mitk::BaseRenderer::GetInstance(renderwindow)->GetSliceNavigationController()->Update(viewDirection,
       m_Controls->cbTop->isChecked(),
       m_Controls->cbFrontSide->isChecked(),
       m_Controls->cbRotated->isChecked()
       );
     mitk::BaseRenderer::GetInstance(renderwindow)->GetDisplayGeometry()->Fit();
   }
 }
 
 void QmitkViewInitializationView::OnResetAll()
 {
   /* calculate bounding geometry of these nodes */
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDefaultDataStorage()->ComputeBoundingGeometry3D();
+  mitk::TimeGeometry::Pointer bounds = this->GetDefaultDataStorage()->ComputeBoundingGeometry3D();
   /* initialize the views to the bounding geometry */
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
 
 vtkRenderWindow* QmitkViewInitializationView::GetSelectedRenderWindow()
 {
   int selectedItem = m_Controls->m_lbRenderWindows->currentRow();
   int itemNumber = 0;
 
   mitk::BaseRenderer::BaseRendererMapType::iterator mapit;
   for(mapit = mitk::BaseRenderer::baseRendererMap.begin();
     mapit != mitk::BaseRenderer::baseRendererMap.end();
     mapit++, itemNumber++)
   {
     if(itemNumber==selectedItem)
       break;
   }
    if(itemNumber==selectedItem)
   {
     return (*mapit).first;
   }
   return NULL;
 }
 
 void QmitkViewInitializationView::InitRenderWindowSelector()
 {
   itk::SimpleMemberCommand<QmitkViewInitializationView>::Pointer updateRendererListCommand =
     itk::SimpleMemberCommand<QmitkViewInitializationView>::New();
   updateRendererListCommand->SetCallbackFunction( this, &QmitkViewInitializationView::UpdateRendererList );
 
   mitk::FocusManager* fm = mitk::GlobalInteraction::GetInstance()->GetFocusManager();
   m_CommandTag = fm->AddObserver(mitk::FocusEvent(), updateRendererListCommand);
 
   this->UpdateRendererList();
 }
 
 void QmitkViewInitializationView::UpdateRendererList()
 {
   vtkRenderWindow* focusedRenderWindow = NULL;
 
   mitk::FocusManager* fm = mitk::GlobalInteraction::GetInstance()->GetFocusManager();
 
   mitk::BaseRenderer::ConstPointer br = fm->GetFocused();
 
   if (br.IsNotNull())
   {
     focusedRenderWindow = br->GetRenderWindow();
   }
 
   int selectedItem = -1;
   int itemNumber = 0;
   m_Controls->m_lbRenderWindows->clear();
 
 
   for(mitk::BaseRenderer::BaseRendererMapType::iterator mapit = mitk::BaseRenderer::baseRendererMap.begin();
     mapit != mitk::BaseRenderer::baseRendererMap.end(); mapit++, itemNumber++)
   {
     if( (*mapit).second->GetName())
     {
       m_Controls->m_lbRenderWindows->addItem(QString((*mapit).second->GetName()));
       if(focusedRenderWindow==(*mapit).first)
         selectedItem = itemNumber;
     }
   }
 
   if (selectedItem>=0)
   {
     m_Controls->m_lbRenderWindows->setCurrentRow(selectedItem);
   }
   else
   {
     m_Controls->m_lbRenderWindows->clearSelection();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
index af866e01e5..da1b6ba0eb 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
@@ -1,898 +1,898 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTTrackingLabView.h"
 #include "QmitkStdMultiWidget.h"
 
 #include <QmitkNDIConfigurationWidget.h>
 #include <QmitkFiducialRegistrationWidget.h>
 #include <QmitkUpdateTimerWidget.h>
 #include <QmitkToolSelectionWidget.h>
 #include <QmitkToolTrackingStatusWidget.h>
 
 
 #include <mitkCone.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkTransform.h>
 #include <itkVector.h>
 
 #include <vtkConeSource.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkAppendPolyData.h>
 #include <vtkLandmarkTransform.h>
 #include <vtkSmartPointer.h>
 #include <vtkPoints.h>
 
 // Qt
 #include <QMessageBox>
 #include <QIcon>
 
 // vtk
 #include <mitkVtkResliceInterpolationProperty.h>
 
 
 const std::string QmitkIGTTrackingLabView::VIEW_ID = "org.mitk.views.igttrackinglab";
 
 QmitkIGTTrackingLabView::QmitkIGTTrackingLabView()
 : QmitkFunctionality()
 ,m_Source(NULL)
 ,m_PermanentRegistrationFilter(NULL)
 ,m_Visualizer(NULL)
 ,m_VirtualView(NULL)
 ,m_PSRecordingPointSet(NULL)
 ,m_RegistrationTrackingFiducialsName("Tracking Fiducials")
 ,m_RegistrationImageFiducialsName("Image Fiducials")
 ,m_PointSetRecordingDataNodeName("Recorded Points")
 ,m_PointSetRecording(false)
 ,m_PermanentRegistration(false)
 ,m_CameraView(false)
 ,m_ImageFiducialsDataNode(NULL)
 ,m_TrackerFiducialsDataNode(NULL)
 ,m_PermanentRegistrationSourcePoints(NULL)
 {
 
   //[-1;0;0] for WOLF_6D bronchoscope
   m_DirectionOfProjectionVector[0]=0;
   m_DirectionOfProjectionVector[1]=0;
   m_DirectionOfProjectionVector[2]=-1;}
 
 QmitkIGTTrackingLabView::~QmitkIGTTrackingLabView()
 {
   if (m_Timer->isActive()) m_Timer->stop();
 }
 
 void QmitkIGTTrackingLabView::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   m_ToolBox = m_Controls.m_ToolBox;
 
   this->CreateBundleWidgets( parent );
   this->CreateConnections();
 }
 
 
 void QmitkIGTTrackingLabView::CreateBundleWidgets( QWidget* parent )
 {
   //initialize registration widget
   m_RegistrationWidget = m_Controls.m_RegistrationWidget;
   m_RegistrationWidget->HideStaticRegistrationRadioButton(true);
   m_RegistrationWidget->HideContinousRegistrationRadioButton(true);
   m_RegistrationWidget->HideUseICPRegistrationCheckbox(true);
 }
 
 
 void QmitkIGTTrackingLabView::CreateConnections()
 {
   m_Timer = new QTimer(this);
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(UpdateTimer()));
   connect( m_ToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnToolBoxCurrentChanged(int)) );
   connect( m_Controls.m_UsePermanentRegistrationToggle, SIGNAL(toggled(bool)), this, SLOT(OnPermanentRegistration(bool)) );
   connect( m_Controls.m_TrackingDeviceSelectionWidget, SIGNAL(NavigationDataSourceSelected(mitk::NavigationDataSource::Pointer)), this, SLOT(OnSetupNavigation()) );
   connect( m_Controls.m_UseAsPointerButton, SIGNAL(clicked()), this, SLOT(OnInstrumentSelected()) );
   connect( m_Controls.m_UseAsObjectmarkerButton, SIGNAL(clicked()), this, SLOT(OnObjectmarkerSelected()) );
   connect( m_RegistrationWidget, SIGNAL(AddedTrackingFiducial()), this, SLOT(OnAddRegistrationTrackingFiducial()) );
   connect( m_RegistrationWidget, SIGNAL(PerformFiducialRegistration()), this, SLOT(OnRegisterFiducials()) );
   connect( m_Controls.m_PointSetRecordCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnPointSetRecording(bool)) );
   connect( m_Controls.m_ActivateNeedleView, SIGNAL(toggled(bool)), this, SLOT(OnVirtualCamera(bool)) );
 
   //start timer
   m_Timer->start(30);
 
   //initialize Combo Boxes
   m_Controls.m_ObjectComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ObjectComboBox->SetAutoSelectNewItems(false);
   m_Controls.m_ObjectComboBox->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   m_Controls.m_ImageComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ImageComboBox->SetAutoSelectNewItems(false);
   m_Controls.m_ImageComboBox->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 }
 
 void QmitkIGTTrackingLabView::UpdateTimer()
 {
   if (m_PermanentRegistration && m_PermanentRegistrationFilter.IsNotNull())
   {
     mitk::Transform::Pointer ObjectMarkerCurrentTransform = mitk::Transform::New(m_ObjectmarkerNavigationData);
     if(IsTransformDifferenceHigh(ObjectMarkerCurrentTransform, m_ObjectmarkerNavigationDataLastUpdate))
     {
       m_ObjectmarkerNavigationDataLastUpdate = mitk::Transform::New(m_ObjectmarkerNavigationData);
       m_PermanentRegistrationFilter->Update();
       //if(m_Controls.m_SurfaceActive->isChecked())
       //{
       //  mitk::Transform::Pointer newTransform = mitk::Transform::New();
       //  newTransform->Concatenate(m_T_MarkerRel);
       //  newTransform->Concatenate(ObjectMarkerCurrentTransform);
       //  this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newTransform->GetAffineTransform3D());
       //}
 
       //if(m_Controls.m_ImageActive->isChecked())
       //{
       //  mitk::AffineTransform3D::Pointer newTransform = mitk::AffineTransform3D::New();
       //  newTransform->SetIdentity();
       //  newTransform->Compose(m_T_ImageGeo);
       //  newTransform->Compose(m_T_MarkerRel->GetAffineTransform3D());
       //  newTransform->Compose(ObjectMarkerCurrentTransform->GetAffineTransform3D());
       //  this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newTransform);
       //}
     }
   }
 
   if (m_CameraView && m_VirtualView.IsNotNull()) {m_VirtualView->Update();}
 
   if(m_PointSetRecording && m_PSRecordingPointSet.IsNotNull())
     {
       int size = m_PSRecordingPointSet->GetSize();
       mitk::NavigationData::Pointer nd = m_PointSetRecordingNavigationData;
 
       if(size > 0)
       {
         mitk::Point3D p = m_PSRecordingPointSet->GetPoint(size-1);
         if(p.EuclideanDistanceTo(nd->GetPosition()) > (double) m_Controls.m_PSRecordingSpinBox->value())
           m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
       }
       else
         m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
     }
   }
 
 
 void QmitkIGTTrackingLabView::OnAddRegistrationTrackingFiducial()
 {
   mitk::NavigationData::Pointer nd = m_InstrumentNavigationData;
 
   if( nd.IsNull() || !nd->IsDataValid())
   {
     QMessageBox::warning( 0, "Invalid tracking data", "Navigation data is not available or invalid!", QMessageBox::Ok );
     return;
   }
 
   if(m_TrackerFiducialsDataNode.IsNotNull() && m_TrackerFiducialsDataNode->GetData() != NULL)
   {
     mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
     ps->InsertPoint(ps->GetSize(), nd->GetPosition());
   }
   else
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker Fiducials. Adding fiducial not possible!");
 }
 
 void QmitkIGTTrackingLabView::OnInstrumentSelected()
 {
   if (m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource().IsNotNull())
     {
     m_InstrumentNavigationData = m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedToolID());
     }
   else
     {
     m_Controls.m_PointerNameLabel->setText("<not available>");
     return;
     }
 
   if (m_InstrumentNavigationData.IsNotNull())
     {
     m_Controls.m_PointerNameLabel->setText(m_InstrumentNavigationData->GetName());
     }
   else
     {
     m_Controls.m_PointerNameLabel->setText("<not available>");
     }
 }
 
 void QmitkIGTTrackingLabView::OnObjectmarkerSelected()
 {
 
 if (m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource().IsNotNull())
     {
     m_ObjectmarkerNavigationData = m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedToolID());
     }
   else
     {
     m_Controls.m_ObjectmarkerNameLabel->setText("<not available>");
     return;
     }
 
   if (m_ObjectmarkerNavigationData.IsNotNull())
     {
     m_Controls.m_ObjectmarkerNameLabel->setText(m_ObjectmarkerNavigationData->GetName());
     }
   else
     {
     m_Controls.m_ObjectmarkerNameLabel->setText("<not available>");
     }
 }
 
 void QmitkIGTTrackingLabView::OnSetupNavigation()
 {
   MITK_INFO << "SetupNavigationCalled";
   if(m_Source.IsNotNull())
     if(m_Source->IsTracking())
       return;
 
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   if(ds == NULL)
   {
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "can not access DataStorage. Navigation not possible");
     return;
   }
 
   // Building up the filter pipeline
   try
   {
     this->SetupIGTPipeline();
 
   }
   catch(std::exception& e)
   {
     QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline: %1").arg(e.what()));
     this->DestroyIGTPipeline(); // destroy the pipeline if building is incomplete
     return;
   }
   catch(...)
   {
     QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline"));
     this->DestroyIGTPipeline();
     return;
   }
 }
 
 void QmitkIGTTrackingLabView::SetupIGTPipeline()
 {
   this->InitializeRegistration(); //initializes the registration widget
 }
 
 void QmitkIGTTrackingLabView::InitializeFilters()
 {
 
 }
 
 void QmitkIGTTrackingLabView::OnRegisterFiducials()
 {
   //Check for initialization
   if (!CheckRegistrationInitialization()) return;
 
   /* retrieve fiducials from data storage */
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
   mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
 
   //convert point sets to vtk poly data
   vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
   for (int i=0; i<imageFiducials->GetSize(); i++)
     {
     double point[3] = {imageFiducials->GetPoint(i)[0],imageFiducials->GetPoint(i)[1],imageFiducials->GetPoint(i)[2]};
     sourcePoints->InsertNextPoint(point);
     double point_targets[3] = {trackerFiducials->GetPoint(i)[0],trackerFiducials->GetPoint(i)[1],trackerFiducials->GetPoint(i)[2]};
     targetPoints->InsertNextPoint(point_targets);
     }
 
   //compute transform
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
   transform->SetSourceLandmarks(sourcePoints);
   transform->SetTargetLandmarks(targetPoints);
   transform->SetModeToRigidBody();
   transform->Modified();
   transform->Update();
 
   //compute FRE
   double FRE = 0;
   for(unsigned int i = 0; i < imageFiducials->GetSize(); i++)
     {
     itk::Point<double> transformed = transform->TransformPoint(imageFiducials->GetPoint(i)[0],imageFiducials->GetPoint(i)[1],imageFiducials->GetPoint(i)[2]);
     double cur_error_squared = transformed.SquaredEuclideanDistanceTo(trackerFiducials->GetPoint(i));
     FRE += cur_error_squared;
     }
 
   FRE = sqrt(FRE/ (double) imageFiducials->GetSize());
   m_Controls.m_RegistrationWidget->SetQualityDisplayText("FRE: " + QString::number(FRE) + " mm");
 
   //convert from vtk to itk data types
   itk::Matrix<float,3,3> rotationFloat = itk::Matrix<float,3,3>();
   itk::Vector<float,3> translationFloat = itk::Vector<float,3>();
   itk::Matrix<double,3,3> rotationDouble = itk::Matrix<double,3,3>();
   itk::Vector<double,3> translationDouble = itk::Vector<double,3>();
 
   vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
   for(int k=0; k<3; k++) for(int l=0; l<3; l++)
   {
     rotationFloat[k][l] = m->GetElement(k,l);
     rotationDouble[k][l] = m->GetElement(k,l);
 
   }
   for(int k=0; k<3; k++)
   {
     translationFloat[k] = m->GetElement(k,3);
     translationDouble[k] = m->GetElement(k,3);
   }
 
   /*MITK_INFO << "MATRIX: ";
   for(int k=0; k<=3; k++)
     {
     MITK_INFO << m->GetElement(k,0) << " " << m->GetElement(k,1) << " " << m->GetElement(k,2) << " " << m->GetElement(k,3);
     }*/
 
   //save transform
   m_T_ObjectReg = mitk::Transform::New();
   m_T_ObjectReg->SetMatrix(m);
 
   //transform surface
   mitk::AffineTransform3D::Pointer newTransform = mitk::AffineTransform3D::New();
   newTransform->SetMatrix(rotationFloat);
   newTransform->SetOffset(translationFloat);
 
   //transform surface
   if(m_Controls.m_SurfaceActive->isChecked() && m_Controls.m_ObjectComboBox->GetSelectedNode().IsNotNull())
   {
     m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newTransform);
   }
 
   //transform ct image
   if(m_Controls.m_ImageActive->isChecked() && m_Controls.m_ImageComboBox->GetSelectedNode().IsNotNull())
   {
     mitk::AffineTransform3D::Pointer imageTransform = m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
     m_T_ImageGeo = mitk::AffineTransform3D::New();
     m_T_ImageGeo->Compose(imageTransform);
     imageTransform->Compose(newTransform);
     mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform... setting the composed directly leads to an error
     itk::Matrix<float,3,3> rotationFloatNew = imageTransform->GetMatrix();
     itk::Vector<float,3> translationFloatNew = imageTransform->GetOffset();
     newImageTransform->SetMatrix(rotationFloatNew);
     newImageTransform->SetOffset(translationFloatNew);
     m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newImageTransform);
     m_T_ImageReg = m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
   }
 
 }
 
 void QmitkIGTTrackingLabView::DestroyIGTPipeline()
 {
   if(m_Source.IsNotNull())
   {
     m_Source->StopTracking();
     m_Source->Disconnect();
     m_Source = NULL;
   }
   m_PermanentRegistrationFilter = NULL;
   m_Visualizer = NULL;
   m_VirtualView = NULL;
 }
 
 void QmitkIGTTrackingLabView::InitializeRegistration()
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   if( ds == NULL )
     return;
 
 
   m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget()); // passing multiwidget to pointsetwidget
 
   if(m_ImageFiducialsDataNode.IsNull())
   {
     m_ImageFiducialsDataNode = mitk::DataNode::New();
     mitk::PointSet::Pointer ifPS = mitk::PointSet::New();
 
     m_ImageFiducialsDataNode->SetData(ifPS);
 
     mitk::Color color;
     color.Set(1.0f, 0.0f, 0.0f);
     m_ImageFiducialsDataNode->SetName(m_RegistrationImageFiducialsName);
     m_ImageFiducialsDataNode->SetColor(color);
     m_ImageFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
 
     ds->Add(m_ImageFiducialsDataNode);
   }
   m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget());
   m_RegistrationWidget->SetImageFiducialsNode(m_ImageFiducialsDataNode);
 
   if(m_TrackerFiducialsDataNode.IsNull())
   {
     m_TrackerFiducialsDataNode = mitk::DataNode::New();
     mitk::PointSet::Pointer tfPS = mitk::PointSet::New();
     m_TrackerFiducialsDataNode->SetData(tfPS);
 
     mitk::Color color;
     color.Set(0.0f, 1.0f, 0.0f);
     m_TrackerFiducialsDataNode->SetName(m_RegistrationTrackingFiducialsName);
     m_TrackerFiducialsDataNode->SetColor(color);
     m_TrackerFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
 
     ds->Add(m_TrackerFiducialsDataNode);
   }
 
   m_RegistrationWidget->SetTrackerFiducialsNode(m_TrackerFiducialsDataNode);
 }
 
 
 void QmitkIGTTrackingLabView::OnToolBoxCurrentChanged(const int index)
 {
   switch (index)
   {
   case RegistrationWidget:
     this->InitializeRegistration();
     break;
 
   default:
     break;
   }
 }
 
 
 mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateRegistrationFiducialsNode( const std::string& label, const mitk::Color& color)
 {
   mitk::DataNode::Pointer fiducialsNode = mitk::DataNode::New();
   mitk::PointSet::Pointer fiducialsPointSet = mitk::PointSet::New();
 
   fiducialsNode->SetData(fiducialsPointSet);
   fiducialsNode->SetName( label );
   fiducialsNode->SetColor( color );
   fiducialsNode->SetBoolProperty( "updateDataOnRender", false );
 
   return fiducialsNode;
 }
 
 
 void QmitkIGTTrackingLabView::ChangeToolRepresentation( int toolID , mitk::Surface::Pointer surface )
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   if(ds == NULL)
   {
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access DataStorage. Changing tool representation not possible!");
     return;
   }
 
   mitk::TrackingDevice::Pointer tracker = m_NDIConfigWidget->GetTracker();
   if(tracker.IsNull())
   {
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker. Changing tool representation not possible!");
     return;
   }
 
   try
   {
     const char* name = tracker->GetTool(toolID)->GetToolName();   // get tool name by id
 
     mitk::DataNode::Pointer toolNode = ds->GetNamedNode(name);
 
     if(toolNode.IsNull())
       return;
 
     toolNode->SetData(surface); // change surface representation of node
     toolNode->SetColor(0.45,0.70,0.85); //light blue like old 5D sensors
     toolNode->Modified();
 
     m_Visualizer->SetRepresentationObject( toolID, toolNode->GetData()); // updating node with changed surface back in visualizer
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   catch(std::exception& e)
   {
     QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Can not change tool representation!").arg(e.what()));
     return;
   }
 }
 
 void QmitkIGTTrackingLabView::OnPointSetRecording(bool record)
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
 
   if(record)
   {
     if (m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedToolID() == -1)
       {
       QMessageBox::warning(NULL, "Error", "No tool selected for point set recording!");
       m_Controls.m_PointSetRecordCheckBox->setChecked(false);
       return;
       }
     m_PointSetRecordingNavigationData = m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedToolID());
 
     //initialize point set
     mitk::DataNode::Pointer psRecND = ds->GetNamedNode(m_PointSetRecordingDataNodeName);
     if(m_PSRecordingPointSet.IsNull() || psRecND.IsNull())
     {
       m_PSRecordingPointSet = NULL;
       m_PSRecordingPointSet = mitk::PointSet::New();
       mitk::DataNode::Pointer dn = mitk::DataNode::New();
       dn->SetName(m_PointSetRecordingDataNodeName);
       dn->SetColor(0.,1.,0.);
       dn->SetData(m_PSRecordingPointSet);
       ds->Add(dn);
     }
     else
     {
       m_PSRecordingPointSet->Clear();
     }
     m_PointSetRecording = true;
   }
 
   else
   {
     m_PointSetRecording = false;
   }
 }
 
 /*void QmitkIGTTrackingLabView::GlobalReinit()
 {
   // request global reiinit
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
 
   // calculate bounding geometry of these nodes
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
   //global reinit end
 }*/
 
 void QmitkIGTTrackingLabView::OnVirtualCamera(bool on)
 {
 if (m_Controls.m_CameraViewSelection->GetSelectedToolID() == -1)
     {
     m_Controls.m_ActivateNeedleView->setChecked(false);
     QMessageBox::warning(NULL, "Error", "No tool selected for camera view!");
     return;
     }
 
 if(on)
   {
   m_VirtualView = mitk::CameraVisualization::New();
   m_VirtualView->SetInput(m_Controls.m_CameraViewSelection->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_CameraViewSelection->GetSelectedToolID()));
 
   mitk::Vector3D viewDirection;
   viewDirection[0] = (int)(m_Controls.m_NeedleViewX->isChecked());
   viewDirection[1] = (int)(m_Controls.m_NeedleViewY->isChecked());
   viewDirection[2] = (int)(m_Controls.m_NeedleViewZ->isChecked());
   if (m_Controls.m_NeedleViewInvert->isChecked()) viewDirection *= -1;
   m_VirtualView->SetDirectionOfProjectionInToolCoordinates(viewDirection);
 
   mitk::Vector3D viewUpVector;
   viewUpVector[0] = (int)(m_Controls.m_NeedleUpX->isChecked());
   viewUpVector[1] = (int)(m_Controls.m_NeedleUpY->isChecked());
   viewUpVector[2] = (int)(m_Controls.m_NeedleUpZ->isChecked());
   if (m_Controls.m_NeedleUpInvert->isChecked()) viewUpVector *= -1;
   m_VirtualView->SetViewUpInToolCoordinates(viewUpVector);
 
   m_VirtualView->SetRenderer(this->GetActiveStdMultiWidget()->GetRenderWindow4()->GetRenderer());
   //next line: better code when this plugin is migrated to mitk::abstractview
   //m_VirtualView->SetRenderer(mitk::BaseRenderer::GetInstance(this->GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow()));
   m_CameraView = true;
 
   //make pointer itself invisible
   m_Controls.m_CameraViewSelection->GetSelectedNavigationTool()->GetDataNode()->SetBoolProperty("visible",false);
 
   //disable UI elements
   m_Controls.m_ViewDirectionBox->setEnabled(false);
   m_Controls.m_ViewUpBox->setEnabled(false);
   }
 else
   {
   m_VirtualView = NULL;
   m_CameraView = false;
   m_Controls.m_CameraViewSelection->GetSelectedNavigationTool()->GetDataNode()->SetBoolProperty("visible",true);
 
   m_Controls.m_ViewDirectionBox->setEnabled(true);
   m_Controls.m_ViewUpBox->setEnabled(true);
   }
 
 }
 
 bool QmitkIGTTrackingLabView::CheckRegistrationInitialization()
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
   mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
 
   if (m_Controls.m_SurfaceActive->isChecked() && m_Controls.m_ObjectComboBox->GetSelectedNode().IsNull())
   {
     std::string warningMessage = "No surface selected for registration.\nRegistration is not possible";
     MITK_WARN << warningMessage;
     QMessageBox::warning(NULL, "Registration not possible", warningMessage.c_str());
     return false;
   }
 
   if (m_Controls.m_ImageActive->isChecked() && m_Controls.m_ImageComboBox->GetSelectedNode().IsNull())
   {
     std::string warningMessage = "No image selected for registration.\nRegistration is not possible";
     MITK_WARN << warningMessage;
     QMessageBox::warning(NULL, "Registration not possible", warningMessage.c_str());
     return false;
   }
 
   if (imageFiducials.IsNull() || trackerFiducials.IsNull())
   {
     std::string warningMessage = "Fiducial data objects not found. \n"
       "Please set 3 or more fiducials in the image and with the tracking system.\n\n"
       "Registration is not possible";
     MITK_WARN << warningMessage;
     QMessageBox::warning(NULL, "Registration not possible", warningMessage.c_str());
     return false;
   }
 
   unsigned int minFiducialCount = 3; // \Todo: move to view option
   if ((imageFiducials->GetSize() < minFiducialCount) || (trackerFiducials->GetSize() < minFiducialCount) || (imageFiducials->GetSize() != trackerFiducials->GetSize()))
   {
     QMessageBox::warning(NULL, "Registration not possible", QString("Not enough fiducial pairs found. At least %1 fiducial must "
       "exist for the image and the tracking system respectively.\n"
       "Currently, %2 fiducials exist for the image, %3 fiducials exist for the tracking system").arg(minFiducialCount).arg(imageFiducials->GetSize()).arg(trackerFiducials->GetSize()));
     return false;
   }
 
   return true;
 }
 
 bool QmitkIGTTrackingLabView::IsTransformDifferenceHigh(mitk::Transform::Pointer transformA, mitk::Transform::Pointer transformB)
 {
   double euclideanDistanceThreshold = .8;
   double angularDifferenceThreshold = .8;
 
   if(transformA.IsNull() || transformA.IsNull())
     {return false;}
   mitk::Point3D posA,posB;
   posA = transformA->GetPosition();
   posB = transformB->GetPosition();
 
 
   if(posA.EuclideanDistanceTo(posB) > euclideanDistanceThreshold)
     {return true;}
 
   double returnValue;
   mitk::Quaternion rotA,rotB;
   rotA = transformA->GetOrientation();
   rotB = transformB->GetOrientation();
 
   itk::Vector<double,3> point; //caution 5D-Tools: Vector must lie in the YZ-plane for a correct result.
   point[0] = 0.0;
   point[1] = 0.0;
   point[2] = 100000.0;
 
   rotA.normalize();
   rotB.normalize();
 
   itk::Matrix<double,3,3> rotMatrixA;
   for(int i=0; i<3; i++) for(int j=0; j<3; j++) rotMatrixA[i][j] = rotA.rotation_matrix_transpose().transpose()[i][j];
 
   itk::Matrix<double,3,3> rotMatrixB;
   for(int i=0; i<3; i++) for(int j=0; j<3; j++) rotMatrixB[i][j] = rotB.rotation_matrix_transpose().transpose()[i][j];
 
   itk::Vector<double,3> pt1 = rotMatrixA * point;
   itk::Vector<double,3> pt2 = rotMatrixB * point;
 
   returnValue = (pt1[0]*pt2[0]+pt1[1]*pt2[1]+pt1[2]*pt2[2]) / ( sqrt(pow(pt1[0],2.0)+pow(pt1[1],2.0)+pow(pt1[2],2.0)) * sqrt(pow(pt2[0],2.0)+pow(pt2[1],2.0)+pow(pt2[2],2.0)));
   returnValue = acos(returnValue);
 
   if(returnValue*57.3 > angularDifferenceThreshold){return true;}
 
   return false;
 }
 
 
 void QmitkIGTTrackingLabView::OnPermanentRegistration(bool on)
 {
   if(on)
     {
 
     if(!CheckRegistrationInitialization())
     {
       m_Controls.m_UsePermanentRegistrationToggle->setChecked(false);
       return;
     }
 
     //remember initial object transform to calculate the object to marker transform later on
     mitk::AffineTransform3D::Pointer transform = this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rotation = vnl_matrix_fixed<mitk::ScalarType,3,3>();
     rotation[0][0] = transform->GetMatrix().GetVnlMatrix()[0][0];
     rotation[0][1] = transform->GetMatrix().GetVnlMatrix()[0][1];
     rotation[0][2] = transform->GetMatrix().GetVnlMatrix()[0][2];
     rotation[1][0] = transform->GetMatrix().GetVnlMatrix()[1][0];
     rotation[1][1] = transform->GetMatrix().GetVnlMatrix()[1][1];
     rotation[1][2] = transform->GetMatrix().GetVnlMatrix()[1][2];
     rotation[2][0] = transform->GetMatrix().GetVnlMatrix()[2][0];
     rotation[2][1] = transform->GetMatrix().GetVnlMatrix()[2][1];
     rotation[2][2] = transform->GetMatrix().GetVnlMatrix()[2][2];
 
     mitk::Point3D translation;
     translation[0] = transform->GetOffset()[0];
     translation[1] = transform->GetOffset()[1];
     translation[2] = transform->GetOffset()[2];
 
 
     mitk::Transform::Pointer T_Object = mitk::Transform::New();
     T_Object->SetPosition(translation);
     T_Object->SetRotation(rotation);
 
     //then reset the transform because we will now start to calculate the permenent registration
     this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIdentity();
 
     if(m_Controls.m_ImageActive->isChecked())
       this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ImageGeo);
 
     //create the permanent registration filter
     m_PermanentRegistrationFilter = mitk::NavigationDataObjectVisualizationFilter::New();
     //set to rotation mode transposed because we are working with VNL style quaternions
     m_PermanentRegistrationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
 
     //first: surface (always activated)
 
     //connect filter to source
     m_PermanentRegistrationFilter->SetInput(0,this->m_ObjectmarkerNavigationData);
 
     //set representation object
     m_PermanentRegistrationFilter->SetRepresentationObject(0,this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData());
 
     //get the marker transform out of the navigation data
     mitk::Transform::Pointer T_Marker = mitk::Transform::New(this->m_ObjectmarkerNavigationData);
 
     //compute transform from object to marker
     mitk::Transform::Pointer T_MarkerRel = mitk::Transform::New();
     T_MarkerRel->Concatenate(T_Object);
     T_Marker->Invert();
     T_MarkerRel->Concatenate(T_Marker);
     m_T_MarkerRel = T_MarkerRel;
 
     //TODO: remove mitk::transform from this class and use only mitk::AffineTransform3D
     //convert to AffineTransform3D
     mitk::AffineTransform3D::Pointer T_MarkerRel_conv = mitk::AffineTransform3D::New();
     {
     itk::Matrix<float,3,3> rotation = itk::Matrix<float,3,3>();
     for(int i = 0; i<3; i++)for (int j=0; j<3; j ++)
     rotation[i][j] = T_MarkerRel->GetVnlRotationMatrix()[i][j];
     itk::Vector<float,3> translation = itk::Vector<float,3>();
     for(int i = 0; i<3; i++) translation[i] = T_MarkerRel->GetPosition()[i];
 
     T_MarkerRel_conv->SetMatrix(rotation);
     T_MarkerRel_conv->SetOffset(translation);
     }
 
 
     m_PermanentRegistrationFilter->SetOffset(0,T_MarkerRel_conv);
 
     //first: image (if activated)
     //set interpolation mode
     if (m_Controls.m_ImageActive->isChecked() && (m_Controls.m_ImageComboBox->GetSelectedNode().IsNotNull()))
       {
       mitk::DataNode::Pointer imageNode = this->m_Controls.m_ImageComboBox->GetSelectedNode();
       imageNode->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_LINEAR) );
       m_PermanentRegistrationFilter->SetInput(1,this->m_ObjectmarkerNavigationData);
       m_PermanentRegistrationFilter->SetRepresentationObject(1,imageNode->GetData());
 
       mitk::AffineTransform3D::Pointer newTransform = mitk::AffineTransform3D::New();
       newTransform->SetIdentity();
       newTransform->Compose(m_T_ImageGeo);
       newTransform->Compose(T_MarkerRel_conv);
       m_PermanentRegistrationFilter->SetOffset(1,newTransform);
       }
 
     //some general stuff
     m_PermanentRegistration = true;
     m_ObjectmarkerNavigationDataLastUpdate = mitk::Transform::New();
 
 
     }
   else
     {
     //stop permanent registration
     m_PermanentRegistration = false;
 
     //restore old registration
     if(m_T_ObjectReg.IsNotNull())
     {
     //convert to AffineTransform3D
     //TODO: remove mitk::transform from this class and use only mitk::AffineTransform3D
     mitk::AffineTransform3D::Pointer m_T_ObjectReg_conv = mitk::AffineTransform3D::New();
     itk::Matrix<float,3,3> rotation = itk::Matrix<float,3,3>();
     for(int i = 0; i<3; i++)for (int j=0; j<3; j ++)
     rotation[i][j] = m_T_ObjectReg->GetVnlRotationMatrix()[i][j];
     itk::Vector<float,3> translation = itk::Vector<float,3>();
     for(int i = 0; i<3; i++) translation[i] = m_T_ObjectReg->GetPosition()[i];
     m_T_ObjectReg_conv->SetMatrix(rotation);
     m_T_ObjectReg_conv->SetOffset(translation);
 
     this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ObjectReg_conv);
     }
     if(m_T_ImageReg.IsNotNull()) this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ImageReg);
 
     //delete filter
     m_PermanentRegistrationFilter = NULL;
     }
 
 
 }
 
 mitk::PointSet::Pointer QmitkIGTTrackingLabView::GetVirtualPointSetFromPosition(mitk::NavigationData::Pointer navigationData)
 {
   typedef itk::QuaternionRigidTransform<double> QuaternionTransformType;
 
   mitk::NavigationData::PositionType pointA;
   mitk::NavigationData::PositionType pointB;
   mitk::NavigationData::PositionType pointC;
 
   //initializing three points with position(0|0|0)
   pointA.Fill(0);
   pointB.Fill(0);
   pointC.Fill(0);
 
   // changing position off all points in order to make them orthogonal
   pointA[0] = 1;
   pointB[1] = 1;
   pointC[2] = 1;
 
   QuaternionTransformType::Pointer quatTransform = QuaternionTransformType::New();
 
   // orientation of NavigationData from parameter
   mitk::NavigationData::OrientationType quatIn = navigationData->GetOrientation();
 
   // set orientation to quaternion transform
   vnl_quaternion<double> const vnlQuatIn(quatIn.x(), quatIn.y(), quatIn.z(), quatIn.r());
   quatTransform->SetRotation(vnlQuatIn);
 
   // transform each point
   pointA = quatTransform->TransformPoint(pointA);
   pointB = quatTransform->TransformPoint(pointB);
   pointC = quatTransform->TransformPoint(pointC);
 
   // add position data from NavigationData parameter to each point
   pointA[0] += navigationData->GetPosition()[0];
   pointA[1] += navigationData->GetPosition()[1];
   pointA[2] += navigationData->GetPosition()[2];
 
   pointB[0] += navigationData->GetPosition()[0];
   pointB[1] += navigationData->GetPosition()[1];
   pointB[2] += navigationData->GetPosition()[2];
 
   pointC[0] += navigationData->GetPosition()[0];
   pointC[1] += navigationData->GetPosition()[1];
   pointC[2] += navigationData->GetPosition()[2];
 
   // insert points in source points pointset for the permanent registration landmark transform
   m_PermanentRegistrationSourcePoints->InsertPoint(0,pointA);
   m_PermanentRegistrationSourcePoints->InsertPoint(1,pointB);
   m_PermanentRegistrationSourcePoints->InsertPoint(2,pointC);
 
 
   return m_PermanentRegistrationSourcePoints;
 }
 
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index 6acb333382..ecc3420b86 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,687 +1,687 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTTrackingToolboxView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 #include <qfiledialog.h>
 
 // MITK
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkTrackingDeviceSourceConfigurator.h>
 #include <mitkTrackingVolumeGenerator.h>
 #include <mitkNDITrackingDevice.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNavigationToolStorageSerializer.h>
 
 // vtk
 #include <vtkSphereSource.h>
 //for exceptions
 #include <mitkIGTException.h>
 #include <mitkIGTIOException.h>
 
 
 
 const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
 
 QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 {
   m_TrackingTimer = new QTimer(this);
   m_tracking = false;
   m_logging = false;
   m_loggedFrames = 0;
 }
 
 QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
 {
 //remove the tracking volume
 this->GetDataStorage()->Remove(m_TrackingVolumeNode);
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
     m_Controls->setupUi( parent );
 
     //create connections
     connect( m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()) );
     connect( m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()) );
     connect( m_Controls->m_Disconnect, SIGNAL(clicked()), this, SLOT(OnDisconnect()) );
     connect( m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()) );
     connect( m_Controls->m_StopTracking, SIGNAL(clicked()), this, SLOT(OnStopTracking()) );
     connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
     connect( m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
     connect( m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
     connect( m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
     connect( m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
     connect( m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
     connect( m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
     connect( m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
     connect( m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
 
     connect( m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
     connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
     connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
 
     //initialize widgets
     m_Controls->m_configurationWidget->EnableAdvancedUserControl(false);
     m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
     m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
 
     //initialize tracking volume node
     m_TrackingVolumeNode = mitk::DataNode::New();
     m_TrackingVolumeNode->SetName("TrackingVolume");
     m_TrackingVolumeNode->SetOpacity(0.25);
     m_TrackingVolumeNode->SetBoolProperty("Backface Culling",true);
     mitk::Color red;
     red.SetRed(1);
     m_TrackingVolumeNode->SetColor(red);
     GetDataStorage()->Add(m_TrackingVolumeNode);
 
     //initialize buttons
     m_Controls->m_Connect->setEnabled(true);
     m_Controls->m_Disconnect->setEnabled(false);
     m_Controls->m_StartTracking->setEnabled(false);
     m_Controls->m_StopTracking->setEnabled(false);
     m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
 
     //Update List of available models for selected tool.
     std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine( m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
     m_Controls->m_VolumeSelectionBox->clear();
     for(int i = 0; i < Compatibles.size(); i++)
     {
       m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
     }
   }
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(NULL,tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
   if (filename.isNull()) return;
 
   //read tool storage from disk
   std::string errorMessage = "";
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
   // try-catch block for exceptions
   try
   {
   m_toolStorage = myDeserializer->Deserialize(filename.toStdString());
   }
   catch(mitk::IGTException)
   {
    std::string errormessage = "Error during deserializing. Problems with file,please check the file?";
    QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
    return;
   }
 
   if(m_toolStorage->isEmpty())
     {
     errorMessage = myDeserializer->GetErrorMessage();
     MessageBox(errorMessage);
     return;
     }
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_toolLabel->setText(toolLabel);
 
   //update tool preview
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnResetTools()
 {
   m_toolStorage = NULL;
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   QString toolLabel = QString("Loaded Tools: <none>");
   m_Controls->m_toolLabel->setText(toolLabel);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnect()
   {
   //check if everything is ready to start tracking
   if (this->m_toolStorage.IsNull())
   {
     MessageBox("Error: No Tools Loaded Yet!");
     return;
   }
   else if (this->m_toolStorage->GetToolCount() == 0)
   {
     MessageBox("Error: No Way To Track Without Tools!");
     return;
   }
 
   //build the IGT pipeline
   mitk::TrackingDevice::Pointer trackingDevice = this->m_Controls->m_configurationWidget->GetTrackingDevice();
 
   //set device to rotation mode transposed becaus we are working with VNL style quaternions
   if(m_Controls->m_InverseMode->isChecked())
     trackingDevice->SetRotationMode(mitk::TrackingDevice::RotationTransposed);
 
   //Get Tracking Volume Data
   mitk::TrackingDeviceData data = mitk::DeviceDataUnspecified;
 
   QString qstr =  m_Controls->m_VolumeSelectionBox->currentText();
   if ( (! qstr.isNull()) || (! qstr.isEmpty()) ) {
     std::string str = qstr.toStdString();
     data = mitk::GetDeviceDataByName(str); //Data will be set later, after device generation
   }
 
   //Create Navigation Data Source with the factory class
   mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(this->m_toolStorage,trackingDevice);
   m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(this->m_ToolVisualizationFilter);
   MITK_INFO << "Number of tools: " << m_TrackingDeviceSource->GetNumberOfOutputs();
 
   //set filter to rotation mode transposed becaus we are working with VNL style quaternions
   if(m_Controls->m_InverseMode->isChecked())
     m_ToolVisualizationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
 
   //First check if the created object is valid
   if (m_TrackingDeviceSource.IsNull())
   {
     MessageBox(myTrackingDeviceSourceFactory->GetErrorMessage());
     return;
   }
 
   //The tools are maybe reordered after initialization, e.g. in case of auto-detected tools of NDI Aurora
   mitk::NavigationToolStorage::Pointer toolsInNewOrder = myTrackingDeviceSourceFactory->GetUpdatedNavigationToolStorage();
   if ((toolsInNewOrder.IsNotNull()) && (toolsInNewOrder->GetToolCount() > 0))
     {
     //so delete the old tools in wrong order and add them in the right order
     //we cannot simply replace the tool storage because the new storage is
     //not correctly initialized with the right data storage
     m_toolStorage->DeleteAllTools();
     for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_toolStorage->AddTool(toolsInNewOrder->GetTool(i));}
     }
 
   //connect to device
   try
     {
     m_TrackingDeviceSource->Connect();
     //Microservice registration:
     m_TrackingDeviceSource->RegisterAsMicroservice();
     m_toolStorage->RegisterAsMicroservice(m_TrackingDeviceSource->GetMicroserviceID());
     }
   catch (...) //todo: change to mitk::IGTException
     {
     MessageBox("Error while starting the tracking device!");
     return;
     }
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(false);
   DisableOptionsButtons();
   DisableTrackingConfigurationButtons();
   m_Controls->m_configurationWidget->ConfigurationFinished();
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
   {
   if (m_tracking) this->OnStopTracking();
 
   m_TrackingDeviceSource->Disconnect();
   m_TrackingDeviceSource->UnRegisterMicroservice();
   //ToolStorages unregisters automatically
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(false);
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(true);
   EnableOptionsButtons();
   EnableTrackingConfigurationButtons();
   m_Controls->m_configurationWidget->Reset();
   m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
 
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
 {
   try
     {
     m_TrackingDeviceSource->StartTracking();
     }
   catch (...) //todo: change to mitk::IGTException
     {
     MessageBox("Error while starting the tracking device!");
     return;
     }
 
   m_TrackingTimer->start(1000/(m_Controls->m_UpdateRate->value()));
   m_Controls->m_TrackingControlLabel->setText("Status: tracking");
 
   //connect the tool visualization widget
   for(int i=0; i<m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
   {
     m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
   }
   m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
   if (m_Controls->m_ShowToolQuaternions->isChecked()) {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true);}
   else {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false);}
 
   //show tracking volume
   this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StopTracking->setEnabled(true);
   m_Controls->m_Connect->setEnabled(false);
 
   m_tracking = true;
 
   this->GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
 {
   if (!m_tracking) return;
   m_TrackingTimer->stop();
   m_TrackingDeviceSource->StopTracking();
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   if (m_logging) StopLogging();
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   m_tracking = false;
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(false);
 
   this->GlobalReinit();
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
 {
   mitk::TrackingDeviceType Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
 
   // Code to enable/disable device specific buttons
   if (Type == mitk::NDIAurora) //Aurora
   {
     m_Controls->m_AutoDetectTools->setVisible(true);
     m_Controls->m_AddSingleTool->setEnabled(false);
   }
   else //Polaris or Microntracker
   {
     m_Controls->m_AutoDetectTools->setVisible(false);
     m_Controls->m_AddSingleTool->setEnabled(true);
   }
 
   // Code to select appropriate tracking volume for current type
   std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine(Type);
   m_Controls->m_VolumeSelectionBox->clear();
   for(int i = 0; i < Compatibles.size(); i++)
   {
     m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
 {
   if (qstr.isNull()) return;
   if (qstr.isEmpty()) return;
   if (m_Controls->m_ShowTrackingVolume->isChecked())
   {
     mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
 
     std::string str = qstr.toStdString();
 
     mitk::TrackingDeviceData data = mitk::GetDeviceDataByName(str);
 
     volumeGenerator->SetTrackingDeviceData(data);
     volumeGenerator->Update();
 
     mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
 
     m_TrackingVolumeNode->SetData(volumeSurface);
 
     GlobalReinit();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
 {
   if (m_Controls->m_ShowTrackingVolume->isChecked())
     {
     OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
     GetDataStorage()->Add(m_TrackingVolumeNode);
     }
   else
     {
     GetDataStorage()->Remove(m_TrackingVolumeNode);
     GlobalReinit();
     }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
 {
 if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAurora)
     {
     DisableTrackingConfigurationButtons();
     mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
     currentDevice->OpenConnection();
     currentDevice->StartTracking();
     mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(this->GetDataStorage());
     for (int i=0; i<currentDevice->GetToolCount(); i++)
       {
       //create a navigation tool with sphere as surface
       std::stringstream toolname;
       toolname << "AutoDetectedTool" << i;
       mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
       newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(currentDevice->GetTool(i))->GetSerialNumber());
       newTool->SetIdentifier(toolname.str());
       newTool->SetTrackingDeviceType(mitk::NDIAurora);
       mitk::DataNode::Pointer newNode = mitk::DataNode::New();
       mitk::Surface::Pointer mySphere = mitk::Surface::New();
       vtkSphereSource *vtkData = vtkSphereSource::New();
       vtkData->SetRadius(3.0f);
       vtkData->SetCenter(0.0, 0.0, 0.0);
       vtkData->Update();
       mySphere->SetVtkPolyData(vtkData->GetOutput());
       vtkData->Delete();
       newNode->SetData(mySphere);
       newNode->SetName(toolname.str());
       newTool->SetDataNode(newNode);
       autoDetectedStorage->AddTool(newTool);
       }
     //save detected tools
     m_toolStorage = autoDetectedStorage;
     //update label
     QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
     m_Controls->m_toolLabel->setText(toolLabel);
     //update tool preview
     m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
     m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
     currentDevice->StopTracking();
     currentDevice->CloseConnection();
 
     EnableTrackingConfigurationButtons();
 
     if (m_toolStorage->GetToolCount()>0)
       {
       //ask the user if he wants to save the detected tools
       QMessageBox msgBox;
       switch(m_toolStorage->GetToolCount())
         {
         case 1:
           msgBox.setText("Found one tool!");
           break;
         default:
           msgBox.setText("Found " + QString::number(m_toolStorage->GetToolCount()) + " tools!");
         }
       msgBox.setInformativeText("Do you want to save this tools as tool storage, so you can load them again?");
       msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
       msgBox.setDefaultButton(QMessageBox::No);
       int ret = msgBox.exec();
 
       if (ret == 16384) //yes
         {
         //ask the user for a filename
         QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save File"),"/",tr("*.IGTToolStorage"));
         //check for empty filename
         if(fileName == "") {return;}
         mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
 
         //when Serialize method is used exceptions are thrown, need to be adapted
         //try-catch block for exception handling in Serializer
         try
         {
         mySerializer->Serialize(fileName.toStdString(),m_toolStorage);
         }
         catch(mitk::IGTException)
         {
         std::string errormessage = "Error during serialization. Please check the Zip file.";
         QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());}
         return;
         }
         else if (ret == 65536) //no
         {
         return;
         }
       }
 
     }
 }
 
 void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
   {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
   }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateTrackingTimer()
   {
   m_ToolVisualizationFilter->Update();
   MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
   MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   if (m_logging)
     {
     this->m_loggingFilter->Update();
     m_loggedFrames = this->m_loggingFilter->GetRecordCounter();
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: "+QString::number(m_loggedFrames));
     //check if logging stopped automatically
     if((m_loggedFrames>1)&&(!m_loggingFilter->GetRecording())){StopLogging();}
     }
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
   {
   QString filename = QFileDialog::getSaveFileName(NULL,tr("Choose Logging File"), "/", "*.*");
   if (filename == "") return;
   this->m_Controls->m_LoggingFileName->setText(filename);
   }
 
 
 void QmitkMITKIGTTrackingToolboxView::StartLogging()
   {
   if (!m_logging)
     {
     //initialize logging filter
     m_loggingFilter = mitk::NavigationDataRecorder::New();
     m_loggingFilter->SetRecordingMode(mitk::NavigationDataRecorder::NormalFile);
     if (m_Controls->m_xmlFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::xml);
     else if (m_Controls->m_csvFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::csv);
     std::string filename = m_Controls->m_LoggingFileName->text().toStdString().c_str();
     // this part has been changed in order to prevent crash of the  program
     if(!filename.empty())
     m_loggingFilter->SetFileName(filename);
     else if(filename.empty()){
      std::string errormessage = "File name has not been set, please set the file name";
      mitkThrowException(mitk::IGTIOException)<<errormessage;
      QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
      m_loggingFilter->SetFileName(filename);
     }
 
     if (m_Controls->m_LoggingLimit->isChecked()){m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value());}
 
     //connect filter
     for(int i=0; i<m_ToolVisualizationFilter->GetNumberOfOutputs(); i++){m_loggingFilter->AddNavigationData(m_ToolVisualizationFilter->GetOutput(i));}
 
     //start filter with try-catch block for exceptions
     try
     {
     m_loggingFilter->StartRecording();
     }
     catch(mitk::IGTException)
     {
     std::string errormessage = "Error during start recording. Recorder already started recording?";
     QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
     m_loggingFilter->StopRecording();
     return;
     }
 
     //update labels / logging variables
     this->m_Controls->m_LoggingLabel->setText("Logging ON");
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
     m_loggedFrames = 0;
     m_logging = true;
     DisableLoggingButtons();
   }
   }
 
 
 
 void QmitkMITKIGTTrackingToolboxView::StopLogging()
   {
   if (m_logging)
     {
     //update label
     this->m_Controls->m_LoggingLabel->setText("Logging OFF");
 
     m_loggingFilter->StopRecording();
     m_logging = false;
     EnableLoggingButtons();
     }
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
   {
   QString Identifier = "Tool#";
   if (m_toolStorage.IsNotNull()) Identifier += QString::number(m_toolStorage->GetToolCount());
   else Identifier += "0";
   m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(),Identifier.toStdString());
   m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(),false);
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
 
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
   {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
   if (this->m_toolStorage.IsNull()) m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
   m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   QString toolLabel = QString("Loaded Tools: <manually added>");
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
   {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
   }
 
 
 void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
 {
 // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
 {
     m_Controls->m_StartLogging->setEnabled(false);
     m_Controls->m_LoggingFileName->setEnabled(false);
     m_Controls->m_ChooseFile->setEnabled(false);
     m_Controls->m_LoggingLimit->setEnabled(false);
     m_Controls->m_LoggedFramesLimit->setEnabled(false);
     m_Controls->m_csvFormat->setEnabled(false);
     m_Controls->m_xmlFormat->setEnabled(false);
     m_Controls->m_StopLogging->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
 {
     m_Controls->m_StartLogging->setEnabled(true);
     m_Controls->m_LoggingFileName->setEnabled(true);
     m_Controls->m_ChooseFile->setEnabled(true);
     m_Controls->m_LoggingLimit->setEnabled(true);
     m_Controls->m_LoggedFramesLimit->setEnabled(true);
     m_Controls->m_csvFormat->setEnabled(true);
     m_Controls->m_xmlFormat->setEnabled(true);
     m_Controls->m_StopLogging->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
 {
     m_Controls->m_ShowTrackingVolume->setEnabled(false);
     m_Controls->m_UpdateRate->setEnabled(false);
     m_Controls->m_ShowToolQuaternions->setEnabled(false);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
 {
     m_Controls->m_ShowTrackingVolume->setEnabled(true);
     m_Controls->m_UpdateRate->setEnabled(true);
     m_Controls->m_ShowToolQuaternions->setEnabled(true);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
 {
     m_Controls->m_AutoDetectTools->setEnabled(true);
     if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(true);
     m_Controls->m_LoadTools->setEnabled(true);
     m_Controls->m_ResetTools->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
 {
     m_Controls->m_AutoDetectTools->setEnabled(false);
     if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(false);
     m_Controls->m_LoadTools->setEnabled(false);
     m_Controls->m_ResetTools->setEnabled(false);
 }
 
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
index 5f154a8535..4badf81dc5 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
@@ -1,476 +1,476 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkNavigationDataPlayerView.h"
 #include "QmitkStdMultiWidget.h"
 
 //mitk
 #include <mitkCone.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 
 // Qt
 #include <QMessageBox>
 
 // vtk
 #include <vtkConeSource.h>
 
 
 const std::string QmitkNavigationDataPlayerView::VIEW_ID = "org.mitk.views.navigationdataplayer";
 
 QmitkNavigationDataPlayerView::QmitkNavigationDataPlayerView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 , m_Trajectory( NULL )
 , m_TrajectoryIndex( -1 )
 , m_ReloadData( true )
 , m_ShowTrajectory( false )
 , m_SplineMapper( NULL )
 , m_PointSetMapper( NULL )
 {
 
   m_TrajectoryPointSet = mitk::PointSet::New(); // PointSet for trajectory points
 }
 
 
 
 QmitkNavigationDataPlayerView::~QmitkNavigationDataPlayerView()
 {
   delete m_PlayerWidget;
 }
 
 
 void QmitkNavigationDataPlayerView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkNavigationDataPlayerViewControls;
     m_Controls->setupUi( parent );
 
     this->CreateBundleWidgets( parent );
     this->CreateConnections();
   }
 }
 
 
 
 void QmitkNavigationDataPlayerView::CreateBundleWidgets(QWidget* parent)
 {
   m_PlayerWidget = new QmitkIGTPlayerWidget( parent );   // this bundle's ND player widget
 }
 
 
 void QmitkNavigationDataPlayerView::CreateConnections()
 {
   connect( m_PlayerWidget, SIGNAL(SignalPlayingStarted()), this, SLOT(OnCreatePlaybackVisualization()) );
   connect( m_PlayerWidget, SIGNAL(SignalPlayerUpdated()), this, SLOT(OnPerformPlaybackVisualization()) );
   connect( m_PlayerWidget, SIGNAL(SignalInputFileChanged()), this, SLOT(OnReinit()) );
   connect( m_PlayerWidget, SIGNAL(SignalCurrentTrajectoryChanged(int)), this, SLOT (OnShowTrajectory(int)) );
   connect( m_PlayerWidget, SIGNAL(SignalPlayingStarted()), this, SLOT(OnPlayingStarted()) );
   connect( m_PlayerWidget, SIGNAL(SignalSplineModeToggled(bool)), this, SLOT(OnEnableSplineTrajectoryMapper(bool)) );
 }
 
 
 void QmitkNavigationDataPlayerView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkNavigationDataPlayerView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 
 void QmitkNavigationDataPlayerView::OnPlayingStarted()
 {
   m_TrajectoryPointSet->Clear(); // clear trajectory data before every replay
 }
 
 void QmitkNavigationDataPlayerView::OnCreatePlaybackVisualization()
 {
   if(m_ReloadData) // only if input file changed
   {
     m_Visualizer = mitk::NavigationDataObjectVisualizationFilter::New();
 
     mitk::DataStorage* ds = this->GetDefaultDataStorage();
 
     unsigned int nrTools = m_PlayerWidget->GetNumberOfTools(); // obtain number of tools from replay file
 
     QStringList toolNames;
     toolNames << "No trajectory selected ..."; // info statement at beginning of trajectories list
 
     for(int i=0; i<nrTools; ++i)
     {
       std::stringstream ss;
       QString nodeName = QString("Replay Tool %1").arg(i).toLatin1();
 
       toolNames << nodeName;
 
       mitk::Color color = this->GetColorCircleColor(i);  // color for replay object
 
       mitk::DataNode::Pointer playbackRepresentation = this->CreateRepresentationObject( nodeName.toStdString(), color  ); // create replay DataNode object
 
       m_Visualizer->SetRepresentationObject(i, playbackRepresentation->GetData()); // add replay object to visualizer
 
       // add new representation object to DataStorage
       this->AddRepresentationObject(this->GetDefaultDataStorage(), playbackRepresentation);
 
     }
 
     this->m_PlayerWidget->SetTrajectoryNames(toolNames); // set names in player widget trajectory selection combobox
     m_ReloadData = false;
 
 
     /// request global reiinit
     mitk::NodePredicateNot::Pointer pred
       = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
       , mitk::BoolProperty::New(false)));
 
     mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
     // calculate bounding geometry of these nodes
-    mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+    mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
     // initialize the views to the bounding geometry
     mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
     /// global reinit end
 
 
 
   }
 
 }
 
 mitk::DataNode::Pointer QmitkNavigationDataPlayerView::CreateTrajectory( mitk::PointSet::Pointer points, const std::string& name, const mitk::Color color )
 {
   mitk::DataNode::Pointer result = mitk::DataNode::New();
 
   // instantiate return DataNode
   result->SetData(points);
   result->SetName(name);
   result->SetColor(color);
 
   mitk::PointSetVtkMapper3D::Pointer mapper;
 
   // create mapper for trajectory visualization
   if(m_PlayerWidget->IsTrajectoryInSplineMode())
     mapper = this->GetTrajectoryMapper(Splines);
   else
     mapper = this->GetTrajectoryMapper(Points);
 
   result->SetMapper(mitk::BaseRenderer::Standard3D, mapper);
 
   // trajectory properties
   result->SetProperty("contourcolor", mitk::ColorProperty::New(color));
   result->SetBoolProperty("show contour", true);
   result->SetBoolProperty("updateDataOnRender", false);
 
   return result;
 }
 
 
 mitk::DataNode::Pointer QmitkNavigationDataPlayerView::CreateRepresentationObject(const std::string& name, const mitk::Color color)
 {
   mitk::DataNode::Pointer representationNode = mitk::DataNode::New();
 
   // creating cone DataNode for tool visualization
   mitk::Cone::Pointer cone = mitk::Cone::New();
   vtkConeSource* vtkData = vtkConeSource::New();
 
   vtkData->SetRadius(7.5);
   vtkData->SetHeight(15.0);
   vtkData->SetDirection(0.0, 0.0, 1.0);
   vtkData->SetCenter(0.0, 0.0, 0.0);
   vtkData->SetResolution(20);
   vtkData->CappingOn();
   vtkData->Update();
 
   cone->SetVtkPolyData(vtkData->GetOutput());
 
   vtkData->Delete();
 
   representationNode->SetData(cone);
 
   representationNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New( name.c_str() ));
   representationNode->GetPropertyList()->SetProperty("layer", mitk::IntProperty::New(0));
   representationNode->GetPropertyList()->SetProperty("visible", mitk::BoolProperty::New(true));
   representationNode->SetColor(color);
   representationNode->SetOpacity(1.0);
   representationNode->Modified();
 
   return representationNode;
 }
 
 
 void QmitkNavigationDataPlayerView::OnPerformPlaybackVisualization()
 {
   if(m_PlayerWidget == NULL || m_Visualizer.IsNull())
     return;
 
   static int update = 0;
   static int counter = -1;
 
   for(unsigned int i = 0 ; i < m_PlayerWidget->GetNavigationDatas().size(); ++i)
   {
     m_Visualizer->SetInput(i, m_PlayerWidget->GetNavigationDatas().at(i)); // pass updated tool NDs to visualizer
 
 
     // show trajectory for selected tool with user given resolution
     if(m_ShowTrajectory && (i == m_TrajectoryIndex) && (update++ % m_PlayerWidget->GetResolution() == 0) )
     {
 
       mitk::PointSet::PointType currentPoint = m_PlayerWidget->GetNavigationDataPoint(i); // current ND point for tool trajectory
 
       // if realtime mode is selected, trajectory points that are equal in position to their antecessor
       // will not be inserted in the trajectory pointset to avoid "vtk can't create normals" warning
       if(m_PlayerWidget->GetCurrentPlaybackMode() == QmitkIGTPlayerWidget::RealTimeMode)
       {
         mitk::PointSet::PointType lastPoint;
         if(counter == -1)
         {
           lastPoint[0] = -1;
           lastPoint[1] = -1;
           lastPoint[2] = -1;
         }
         else
           lastPoint = m_TrajectoryPointSet->GetPoint(counter); // antecessor point is last point from PointSet
 
         mitk::PointSet::PointType currentPoint = m_PlayerWidget->GetNavigationDataPoint(i);
 
         // check for position differences between last and current point
         bool diff0 = lastPoint[0] != currentPoint[0];
         bool diff1 = lastPoint[1] != currentPoint[1];
         bool diff2 = lastPoint[2] != currentPoint[2];
 
         if(diff0 || diff1 || diff2)
           m_TrajectoryPointSet->InsertPoint(++counter,  currentPoint); // insert only if there are differences
       }
       else
       {
         m_TrajectoryPointSet->InsertPoint(++counter, currentPoint); // insert point in trajectory PointSet
       }
 
     }
   }
 
   this->RenderScene();
 }
 
 void QmitkNavigationDataPlayerView::RenderScene()
 {
   try
   {
     if (m_Visualizer.IsNull() || this->GetActiveStdMultiWidget() == NULL)
       return;
 
     try
     {
       m_Visualizer->Update();
     }
     catch(std::exception& e)
     {
       std::cout << "Exception during QmitkNavigationDataPlayerView::RenderScene():" << e.what() << "\n";
     }
 
     //update all Widgets
     // mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
 
     // update only Widget4
     mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget4->GetRenderWindow())->RequestUpdate();  // update 3D render window
   }
   catch (std::exception& e)
   {
     std::cout << "RenderAll exception: " << e.what() << "\n";
   }
   catch (...)
   {
     std::cout << "RenderAll unknown exception\n";
   }
 }
 
 void QmitkNavigationDataPlayerView::OnReinit()
 {
 
   std::vector<mitk::DataNode::Pointer>::iterator it;
 
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
 
   // clear tool representation objects from DataStorage
   for ( it = m_RepresentationObjects.begin() ; it != m_RepresentationObjects.end(); it++ )
   {
     //ds->Remove(*it);
     mitk::DataNode::Pointer dn = ds->GetNamedNode((*it)->GetName());
     if(dn.IsNotNull())
       ds->Remove(dn);
   }
 
   m_RepresentationObjects.clear();  // clear tool representation objects vector
 
   if(m_Trajectory.IsNotNull())
     this->GetDefaultDataStorage()->Remove(m_Trajectory); // remove trajectory DataNode from DataStorage
 
   m_TrajectoryPointSet->Clear(); // clear trajectory PointSet
   this->m_PlayerWidget->ClearTrajectorySelectCombobox(); // clear trajectory selection combobox in player widget
 
   m_ReloadData = true; // set flag to true so representation data will be reload if play is triggered again
 
 }
 
 void QmitkNavigationDataPlayerView::AddTrajectory(mitk::DataStorage* ds, mitk::DataNode::Pointer trajectoryNode)
 {
   if(ds == NULL)
     return;
 
   if(m_Trajectory.IsNotNull())
     ds->Remove(m_Trajectory);  // remove trajectory from DataStorage if already exists
 
 
   // add trajectory to DataStorage
   if(ds != NULL && trajectoryNode.IsNotNull())
   {
     m_Trajectory = trajectoryNode;
     ds->Add(m_Trajectory);
   }
 }
 
 void QmitkNavigationDataPlayerView::AddRepresentationObject(mitk::DataStorage* ds, mitk::DataNode::Pointer reprObject)
 {
   m_RepresentationObjects.push_back(reprObject);
   ds->Add(reprObject);
 }
 
 void QmitkNavigationDataPlayerView::RemoveRepresentationObject(mitk::DataStorage* ds, mitk::DataNode::Pointer reprObject)
 {
   std::vector<mitk::DataNode::Pointer>::iterator it;
 
   for ( it = m_RepresentationObjects.begin() ; it != m_RepresentationObjects.end(); it++ )
   {
     if(*it == reprObject)
     {
       m_RepresentationObjects.erase(it);
       ds->Remove(reprObject);
     }
   }
 }
 
 void QmitkNavigationDataPlayerView::OnShowTrajectory(int index)
 {
 
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
 
 
   // no trajectory selected
   if(index == 0)
   {
     m_ShowTrajectory = false;
     m_TrajectoryIndex = -1;
 
     if(m_Trajectory.IsNotNull())
       ds->Remove(m_Trajectory);
   }
 
   else
   {
     m_ShowTrajectory = true;
 
     // index-1 because combobox is filled with infovalue at index = 0
     mitk::DataNode::Pointer replayObject = m_RepresentationObjects.at(index-1);
 
     std::string prefix("Trajectory of ");
     std::string name = replayObject->GetName();
 
     mitk::Color color = this->GetColorCircleColor(index-1);
 
     if(m_TrajectoryPointSet.IsNotNull())
       m_TrajectoryPointSet->Clear();
 
     m_TrajectoryIndex = index-1;
 
     mitk::DataNode::Pointer trajectory = this->CreateTrajectory( m_TrajectoryPointSet, prefix.append(name), color );
     this->AddTrajectory(this->GetDefaultDataStorage(), trajectory);
   }
 }
 
 
 void QmitkNavigationDataPlayerView::OnEnableSplineTrajectoryMapper(bool enable)
 {
   if(m_Trajectory.IsNull())
     return;
 
   // if enabled set spline mapper
   if(enable)
     m_Trajectory->SetMapper(mitk::BaseRenderer::Standard3D, this->GetTrajectoryMapper(Splines));
 
   // if disabled set pointset mapper
   else
     m_Trajectory->SetMapper(mitk::BaseRenderer::Standard3D, this->GetTrajectoryMapper(Points));
 
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // request update after mapper change
 }
 
 
 
 mitk::Color QmitkNavigationDataPlayerView::GetColorCircleColor(int index)
 {
   mitk::Color result;
 
   mitk::ColorSequenceCycleH colorCycle;
 
   for(int i=0; i <= index; ++i)
   {
     result = colorCycle.GetNextColor();
   }
 
   return result;
 }
 
 
 mitk::PointSetVtkMapper3D::Pointer QmitkNavigationDataPlayerView::GetTrajectoryMapper(TrajectoryStyle style)
 {
   if(style == Points)
   {
     if(m_PointSetMapper.IsNull())
       m_PointSetMapper = mitk::PointSetVtkMapper3D::New();
 
     return m_PointSetMapper;
   }
 
   else if(style == Splines)
   {
     if(m_SplineMapper.IsNull())
       m_SplineMapper = mitk::SplineVtkMapper3D::New();
 
     return  m_SplineMapper.GetPointer();
   }
   else
     return NULL;
 }
 
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
index 83c1d09fae..cc421beaed 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
@@ -1,454 +1,454 @@
 /*===================================================================
 
 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 <iostream>
 
 #include "QmitkImageCropper.h"
 #include <QAction>
 
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QCheckBox>
 #include <QSpinBox>
 #include <QSlider>
 #include <vtkRenderWindow.h>
 
 
 #include <mitkEllipsoid.h>
 #include <mitkCylinder.h>
 #include <mitkCone.h>
 #include <mitkRenderingManager.h>
 #include <mitkProperties.h>
 #include <mitkGlobalInteraction.h>
 #include "mitkUndoController.h"
 #include "mitkBoundingObjectCutter.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkITKImageImport.h"
 #include "mitkIDataStorageService.h"
 #include "mitkNodePredicateDataType.h"
 
 #include <itkCommand.h>
 
 //to be moved to mitkInteractionConst.h by StateMachineEditor
 const mitk::OperationType QmitkImageCropper::OP_EXCHANGE = 717;
 
 // constructors for operation classes
 QmitkImageCropper::opExchangeNodes::opExchangeNodes( mitk::OperationType type, mitk::DataNode* node, mitk::BaseData* oldData, mitk::BaseData* newData )
 :mitk::Operation(type),m_Node(node),m_OldData(oldData),m_NewData(newData), m_NodeDeletedObserverTag(0), m_OldDataDeletedObserverTag(0),
 m_NewDataDeletedObserverTag(0)
 {
   // listen to the node the image is hold
   itk::MemberCommand<opExchangeNodes>::Pointer nodeDeletedCommand = itk::MemberCommand<opExchangeNodes>::New();
   nodeDeletedCommand->SetCallbackFunction(this, &opExchangeNodes::NodeDeleted);
 
   m_NodeDeletedObserverTag = m_Node->AddObserver(itk::DeleteEvent(), nodeDeletedCommand);
   m_OldDataDeletedObserverTag = m_OldData->AddObserver(itk::DeleteEvent(), nodeDeletedCommand);
   m_NewDataDeletedObserverTag = m_NewData->AddObserver(itk::DeleteEvent(), nodeDeletedCommand);
 }
 
 // destructor for operation class
 QmitkImageCropper::opExchangeNodes::~opExchangeNodes()
 {
   if (m_Node != NULL)
   {
     m_Node->RemoveObserver(m_NodeDeletedObserverTag);
     m_Node=NULL;
   }
 
   if (m_OldData.IsNotNull())
   {
     m_OldData->RemoveObserver(m_OldDataDeletedObserverTag);
     m_OldData=NULL;
   }
 
   if (m_NewData.IsNotNull())
   {
     m_NewData->RemoveObserver(m_NewDataDeletedObserverTag);
     m_NewData=NULL;
   }
 }
 
 void QmitkImageCropper::opExchangeNodes::NodeDeleted(const itk::Object * /*caller*/, const itk::EventObject &/*event*/)
 {
   m_Node = NULL;
   m_OldData = NULL;
   m_NewData = NULL;
 }
 
 QmitkImageCropper::QmitkImageCropper(QObject *parent)
 : m_Controls(NULL), m_ParentWidget(0)
 {
    m_Interface = new mitk::ImageCropperEventInterface;
    m_Interface->SetImageCropper( this );
 }
 
 
 QmitkImageCropper::~QmitkImageCropper()
 {
   //delete smart pointer objects
   m_CroppingObjectNode = NULL;
   m_CroppingObject = NULL;
 
   m_Interface->Delete();
 
 }
 
 void QmitkImageCropper::CreateQtPartControl(QWidget* parent)
 {
   if (!m_Controls)
   {
     m_ParentWidget = parent;
 
     // build ui elements
     m_Controls = new Ui::QmitkImageCropperControls;
     m_Controls->setupUi(parent);
 
     // setup ui elements
     m_Controls->groupInfo->hide();
     m_Controls->m_SurroundingSlider->hide();
     m_Controls->m_SurroundingSpin->hide();
     m_Controls->m_BoxButton->setEnabled(true);
     m_Controls->warningLabel->setVisible(false);
     // create ui element connections
     this->CreateConnections();
   }
 
 }
 
 void QmitkImageCropper::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( m_Controls->m_CropButton, SIGNAL(clicked()), this, SLOT(CropImage()));   // click on the crop button
     connect( m_Controls->m_BoxButton, SIGNAL(clicked()), this, SLOT(CreateNewBoundingObject()) );
     connect( m_Controls->m_EnableSurroundingCheckBox, SIGNAL(toggled(bool)), this, SLOT(SurroundingCheck(bool)) );
     connect( m_Controls->chkInformation, SIGNAL(toggled(bool)), this, SLOT(ChkInformationToggled(bool)) );
   }
 }
 
 void QmitkImageCropper::Activated()
 {
   QmitkFunctionality::Activated();  // just call the inherited function
 }
 
 
 void QmitkImageCropper::Deactivated()
 {
   RemoveBoundingObjectFromNode();
 
   QmitkFunctionality::Deactivated(); // just call the inherited function
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 /*! When called with an opExchangeNodes, it changes the content of a node from one data set to another
 */
 void QmitkImageCropper::ExecuteOperation (mitk::Operation *operation)
 {
   if (!operation) return;
 
   switch (operation->GetOperationType())
   {
   case OP_EXCHANGE:
     {
       //RemoveBoundingObjectFromNode();
       opExchangeNodes* op = static_cast<opExchangeNodes*>(operation);
       op->GetNode()->SetData(op->GetNewData());
       mitk::RenderingManager::GetInstance()->InitializeViews();
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
   default:;
   }
 
 }
 
 void QmitkImageCropper::CreateNewBoundingObject()
 {
   // attach the cuboid to the image and update the views
   if (this->IsVisible())
   {
     if (m_ImageNode.IsNotNull())
     {
       m_ImageToCrop = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
 
       if(m_ImageToCrop.IsNotNull())
       {
         if (this->GetDefaultDataStorage()->GetNamedDerivedNode("CroppingObject", m_ImageNode))
         {
           //Remove m_Cropping
           this->RemoveBoundingObjectFromNode();
         }
 
         bool fitCroppingObject = false;
         if(m_CroppingObject.IsNull())
         {
           CreateBoundingObject();
           fitCroppingObject = true;
         }
 
         if (m_CroppingObject.IsNull())
           return;
 
         AddBoundingObjectToNode( m_ImageNode, fitCroppingObject );
 
         m_ImageNode->SetVisibility(true);
         mitk::RenderingManager::GetInstance()->InitializeViews();
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         m_Controls->m_BoxButton->setText("Reset bounding box!");
         m_Controls->m_CropButton->setEnabled(true);
       }
     }
     else
       QMessageBox::information(NULL, "Image cropping functionality", "Load an image first!");
   }
 }
 
 
 void QmitkImageCropper::SurroundingCheck(bool value)
 {
   if(value)
   {
    if(m_ImageNode.IsNotNull())
     {
       mitk::DataNode *imageNode = m_ImageNode.GetPointer();
       if (imageNode)
       {
         mitk::BaseData* data = imageNode->GetData();
         if (data)
         {
           // test if this data item is an image or not (could also be a surface or something totally different)
           mitk::Image* image = dynamic_cast<mitk::Image*>( data );
           if (image)
           {
             float min = 10000.0;
             float max = -10000.0;
 
             min = image->GetScalarValueMin();
             max = image->GetScalarValueMax();
 
             m_Controls->m_SurroundingSlider->setRange((int)min,(int)max);
             m_Controls->m_SurroundingSpin->setRange((int)min,(int)max);
           }
         }
       }
       m_Controls->m_SurroundingSlider->show();
       m_Controls->m_SurroundingSpin->show();
     }
     else
       m_Controls->m_EnableSurroundingCheckBox->setChecked(false);
   }
   else
   {
     m_Controls->m_SurroundingSlider->hide();
     m_Controls->m_SurroundingSpin->hide();
   }
 }
 
 void QmitkImageCropper::CropImage()
 {
   // test, if image is selected
   if (m_ImageToCrop.IsNull()) return;
 
   // test, if bounding box is visible
   if (m_CroppingObjectNode.IsNull())
   {
     QMessageBox::information(NULL, "Image cropping functionality", "Generate a new bounding object first!");
     return;
   }
 
   // image and bounding object ok
   mitk::BoundingObjectCutter::Pointer cutter = mitk::BoundingObjectCutter::New();
   cutter->SetBoundingObject( m_CroppingObject );
   cutter->SetInput( m_ImageToCrop );
   cutter->AutoOutsideValueOff();
 
   if (m_Controls->m_EnableSurroundingCheckBox->isChecked())
   {
     cutter->SetOutsideValue(m_Controls->m_SurroundingSpin->value());
   }
 
   // do the actual cutting
   try
   {
     cutter->Update();
     //cutter->UpdateLargestPossibleRegion();
   }
   catch(itk::ExceptionObject&)
   {
     QMessageBox::warning ( NULL,
       tr("Cropping not possible"),
       tr("Sorry, the bounding box has to be completely inside the image.\n\n"
       "The possibility to drag it larger than the image is a bug and has to be fixed."),
       QMessageBox::Ok,  QMessageBox::NoButton,  QMessageBox::NoButton );
     return;
   }
 
   // cutting successful
   mitk::Image::Pointer resultImage = cutter->GetOutput();
   resultImage->DisconnectPipeline();
 
   RemoveBoundingObjectFromNode();
 
   {
     opExchangeNodes*  doOp   = new opExchangeNodes(OP_EXCHANGE, m_ImageNode.GetPointer(),
       m_ImageNode->GetData(),
       resultImage);
     opExchangeNodes* undoOp  = new opExchangeNodes(OP_EXCHANGE, m_ImageNode.GetPointer(),
       resultImage,
       m_ImageNode->GetData());
 
     // TODO: MITK doesn't recognize that a new event happens in the next line,
     //       because nothing happens in the render window.
     //       As a result the undo action will happen together with the last action
     //       recognized by MITK.
     mitk::OperationEvent* operationEvent = new mitk::OperationEvent( m_Interface, doOp, undoOp, "Crop image");
     mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( operationEvent ); // tell the undo controller about the action
 
     ExecuteOperation(doOp); // execute action
   }
 
   m_Controls->m_BoxButton->setEnabled(true);
   m_Controls->m_CropButton->setEnabled(false);
 }
 
 void QmitkImageCropper::CreateBoundingObject()
 {
   QStringList items;
   items << tr("Cuboid") << tr("Ellipsoid") << tr("Cylinder") << tr("Cone");
 
   bool ok;
   QString item = QInputDialog::getItem(m_Parent, tr("Select Bounding Object"), tr("Type of Bounding Object:"), items, 0, false, &ok);
 
   if (!ok)
     return;
 
   if (item == "Ellipsoid")
     m_CroppingObject = mitk::Ellipsoid::New();
   else if(item == "Cylinder")
     m_CroppingObject = mitk::Cylinder::New();
   else if (item == "Cone")
     m_CroppingObject = mitk::Cone::New();
   else if (item == "Cuboid")
     m_CroppingObject = mitk::Cuboid::New();
   else
     return;
 
   m_CroppingObjectNode = mitk::DataNode::New();
   m_CroppingObjectNode->SetData( m_CroppingObject );
   m_CroppingObjectNode->SetProperty( "name", mitk::StringProperty::New( "CroppingObject" ) );
   m_CroppingObjectNode->SetProperty( "color", mitk::ColorProperty::New(1.0, 1.0, 0.0) );
   m_CroppingObjectNode->SetProperty( "opacity", mitk::FloatProperty::New(0.4) );
   m_CroppingObjectNode->SetProperty( "layer", mitk::IntProperty::New(99) ); // arbitrary, copied from segmentation functionality
   m_CroppingObjectNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
 
   m_AffineInteractor = mitk::AffineInteractor::New("AffineInteractions ctrl-drag", m_CroppingObjectNode);
 }
 
 void QmitkImageCropper::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   this->RemoveBoundingObjectFromNode();
 
   if (nodes.size() != 1 || dynamic_cast<mitk::Image*>(nodes[0]->GetData()) == 0)
   {
     m_ParentWidget->setEnabled(false);
     m_Controls->warningLabel->setVisible(false);
     return;
   }
 
   m_ImageNode = nodes[0];
   m_ParentWidget->setEnabled(true);
   // do not accept datanodes with dimension of less than three
   mitk::Image* m_ImageToCrop = dynamic_cast<mitk::Image*>(nodes[0]->GetData());
   if (m_ImageToCrop == NULL)
   {
     return;
   }
   unsigned int dim = m_ImageToCrop->GetDimension();
   if (dim < 3)
   {
     m_Controls->warningLabel->setVisible(true);
     m_ParentWidget->setEnabled(false);
   }
   else
   {
     m_Controls->warningLabel->setVisible(false);
   }
 }
 
 void QmitkImageCropper::AddBoundingObjectToNode(mitk::DataNode* node, bool fit)
 {
   m_ImageToCrop = dynamic_cast<mitk::Image*>(node->GetData());
   unsigned int dim = m_ImageToCrop->GetDimension();
   if (dim < 3)
   {
     MITK_WARN << "Image Cropper does not support 1D/2D Objects. Aborting operation";
     return;
   }
   if(!this->GetDefaultDataStorage()->Exists(m_CroppingObjectNode))
   {
     this->GetDefaultDataStorage()->Add(m_CroppingObjectNode, node);
     if (fit)
     {
-      m_CroppingObject->FitGeometry(m_ImageToCrop->GetTimeSlicedGeometry());
+      m_CroppingObject->FitGeometry(m_ImageToCrop->GetGeometry());
     }
 
     mitk::GlobalInteraction::GetInstance()->AddInteractor( m_AffineInteractor );
   }
   m_CroppingObjectNode->SetVisibility(true);
 }
 
 void QmitkImageCropper::RemoveBoundingObjectFromNode()
 {
   if (m_CroppingObjectNode.IsNotNull())
   {
     if(this->GetDefaultDataStorage()->Exists(m_CroppingObjectNode))
     {
       this->GetDefaultDataStorage()->Remove(m_CroppingObjectNode);
       mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_AffineInteractor);
       m_CroppingObject = NULL;
     }
     m_Controls->m_BoxButton->setText("New bounding box!");
   }
 }
 
 void QmitkImageCropper::ChkInformationToggled( bool on )
 {
   if (on)
     m_Controls->groupInfo->show();
   else
     m_Controls->groupInfo->hide();
 }
 
 void QmitkImageCropper::StdMultiWidgetAvailable( QmitkStdMultiWidget&  stdMultiWidget )
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkImageCropper::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkImageCropper::NodeRemoved(const mitk::DataNode *node)
 {
   std::string name = node->GetName();
 
   if (strcmp(name.c_str(), "CroppingObject")==0)
   {
     m_Controls->m_CropButton->setEnabled(false);
     m_Controls->m_BoxButton->setEnabled(true);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
index 3f3b5ac67e..bfbcf73b5e 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
@@ -1,398 +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 "QmitkImageNavigatorView.h"
 
 #include <QmitkStepperAdapter.h>
 #include <QmitkRenderWindow.h>
 
+#include <mitkTimeGeometry.h>
+
 #include <berryConstants.h>
 
 
 const std::string QmitkImageNavigatorView::VIEW_ID = "org.mitk.views.imagenavigator";
 
 
 QmitkImageNavigatorView::QmitkImageNavigatorView()
   : m_AxialStepper(0)
   , m_SagittalStepper(0)
   , m_FrontalStepper(0)
   , m_TimeStepper(0)
   , m_Parent(0)
   , m_IRenderWindowPart(0)
 {
 }
 
 QmitkImageNavigatorView::~QmitkImageNavigatorView()
 {
 }
 
 void QmitkImageNavigatorView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
   m_Controls.m_SliceNavigatorAxial->SetInverseDirection(true);
 
   connect(m_Controls.m_XWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_YWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_ZWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
 
   m_Parent->setEnabled(false);
 
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   this->RenderWindowPartActivated(renderPart);
 }
 
 void QmitkImageNavigatorView::SetFocus ()
 {
   m_Controls.m_XWorldCoordinateSpinBox->setFocus();
 }
 
 void QmitkImageNavigatorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (this->m_IRenderWindowPart != renderWindowPart)
   {
     this->m_IRenderWindowPart = renderWindowPart;
     this->m_Parent->setEnabled(true);
 
     QmitkRenderWindow* renderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       if (m_AxialStepper) m_AxialStepper->deleteLater();
       m_AxialStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorAxial,
                                                      renderWindow->GetSliceNavigationController()->GetSlice(),
                                                      "sliceNavigatorAxialFromSimpleExample");
       m_Controls.m_SliceNavigatorAxial->setEnabled(true);
       m_Controls.m_AxialLabel->setEnabled(true);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(true);
       connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
     }
     else
     {
       m_Controls.m_SliceNavigatorAxial->setEnabled(false);
       m_Controls.m_AxialLabel->setEnabled(false);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       if (m_SagittalStepper) m_SagittalStepper->deleteLater();
       m_SagittalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorSagittal,
                                                   renderWindow->GetSliceNavigationController()->GetSlice(),
                                                   "sliceNavigatorSagittalFromSimpleExample");
       m_Controls.m_SliceNavigatorSagittal->setEnabled(true);
       m_Controls.m_SagittalLabel->setEnabled(true);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(true);
       connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
     }
     else
     {
       m_Controls.m_SliceNavigatorSagittal->setEnabled(false);
       m_Controls.m_SagittalLabel->setEnabled(false);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
       if (m_FrontalStepper) m_FrontalStepper->deleteLater();
       m_FrontalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorFrontal,
                                                  renderWindow->GetSliceNavigationController()->GetSlice(),
                                                  "sliceNavigatorFrontalFromSimpleExample");
       m_Controls.m_SliceNavigatorFrontal->setEnabled(true);
       m_Controls.m_CoronalLabel->setEnabled(true);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(true);
       connect(m_FrontalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
     }
     else
     {
       m_Controls.m_SliceNavigatorFrontal->setEnabled(false);
       m_Controls.m_CoronalLabel->setEnabled(false);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(false);
     }
 
     mitk::SliceNavigationController* timeController = renderWindowPart->GetTimeNavigationController();
     if (timeController)
     {
       if (m_TimeStepper) m_TimeStepper->deleteLater();
       m_TimeStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorTime,
                                               timeController->GetTime(),
                                               "sliceNavigatorTimeFromSimpleExample");
       m_Controls.m_SliceNavigatorTime->setEnabled(true);
       m_Controls.m_TimeLabel->setEnabled(true);
     }
     else
     {
       m_Controls.m_SliceNavigatorTime->setEnabled(false);
       m_Controls.m_TimeLabel->setEnabled(false);
     }
   }
 }
 
 void QmitkImageNavigatorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_IRenderWindowPart = 0;
   m_Parent->setEnabled(false);
 }
 
 int QmitkImageNavigatorView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkImageNavigatorView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return 200;
   }
   else
   {
     return preferredResult;
   }
 }
 
 int QmitkImageNavigatorView::GetClosestAxisIndex(mitk::Vector3D normal)
 {
   // cos(theta) = normal . axis
   // cos(theta) = (a, b, c) . (d, e, f)
   // cos(theta) = (a, b, c) . (1, 0, 0) = a
   // cos(theta) = (a, b, c) . (0, 1, 0) = b
   // cos(theta) = (a, b, c) . (0, 0, 1) = c
   double absCosThetaWithAxis[3];
 
   for (int i = 0; i < 3; i++)
   {
     absCosThetaWithAxis[i] = fabs(normal[i]);
   }
   int largestIndex = 0;
   double largestValue = absCosThetaWithAxis[0];
   for (int i = 1; i < 3; i++)
   {
     if (absCosThetaWithAxis[i] > largestValue)
     {
       largestValue = absCosThetaWithAxis[i];
       largestIndex = i;
     }
   }
   return largestIndex;
 }
 
 void QmitkImageNavigatorView::SetBorderColors()
 {
   if (m_IRenderWindowPart)
   {
     QmitkRenderWindow* renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, QString("red"));
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, QString("green"));
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, QString("blue"));
       }
     }
   }
 }
 
 void QmitkImageNavigatorView::SetBorderColor(int axis, QString colorAsStyleSheetString)
 {
   if (axis == 0)
   {
     this->SetBorderColor(m_Controls.m_XWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 1)
   {
     this->SetBorderColor(m_Controls.m_YWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 2)
   {
     this->SetBorderColor(m_Controls.m_ZWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
 }
 
 void QmitkImageNavigatorView::SetBorderColor(QDoubleSpinBox *spinBox, QString colorAsStyleSheetString)
 {
   assert(spinBox);
   spinBox->setStyleSheet(QString("border: 2px solid ") + colorAsStyleSheetString + ";");
 }
 
 void QmitkImageNavigatorView::SetStepSizes()
 {
   this->SetStepSize(0);
   this->SetStepSize(1);
   this->SetStepSize(2);
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis)
 {
   if (m_IRenderWindowPart)
   {
-    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
+    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry3D();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D crossPositionInIndexCoordinates;
       mitk::Point3D crossPositionInIndexCoordinatesPlus1;
       mitk::Point3D crossPositionInMillimetresPlus1;
       mitk::Vector3D transformedAxisDirection;
 
       mitk::Point3D crossPositionInMillimetres = m_IRenderWindowPart->GetSelectedPosition();
       geometry->WorldToIndex(crossPositionInMillimetres, crossPositionInIndexCoordinates);
 
       crossPositionInIndexCoordinatesPlus1 = crossPositionInIndexCoordinates;
       crossPositionInIndexCoordinatesPlus1[axis] += 1;
 
       geometry->IndexToWorld(crossPositionInIndexCoordinatesPlus1, crossPositionInMillimetresPlus1);
 
       transformedAxisDirection = crossPositionInMillimetresPlus1 - crossPositionInMillimetres;
 
       int closestAxisInMillimetreSpace = this->GetClosestAxisIndex(transformedAxisDirection);
       double stepSize = transformedAxisDirection.GetNorm();
       this->SetStepSize(closestAxisInMillimetreSpace, stepSize);
     }
   }
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis, double stepSize)
 {
   if (axis == 0)
   {
     m_Controls.m_XWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 1)
   {
     m_Controls.m_YWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 2)
   {
     m_Controls.m_ZWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
 }
 
 void QmitkImageNavigatorView::OnMillimetreCoordinateValueChanged()
 {
   if (m_IRenderWindowPart)
   {
-    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
+    mitk::TimeGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D positionInWorldCoordinates;
       positionInWorldCoordinates[0] = m_Controls.m_XWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[1] = m_Controls.m_YWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[2] = m_Controls.m_ZWorldCoordinateSpinBox->value();
 
       m_IRenderWindowPart->SetSelectedPosition(positionInWorldCoordinates);
     }
   }
 }
 
 void QmitkImageNavigatorView::OnRefetch()
 {
   if (m_IRenderWindowPart)
   {
-    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
+    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry3D();
+    mitk::TimeGeometry::ConstPointer timeGeometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
+
+    if (geometry.IsNull() && timeGeometry.IsNotNull())
+    {
+      mitk::TimeStepType timeStep = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetTime()->GetPos();
+      geometry = timeGeometry->GetGeometryForTimeStep(timeStep);
+    }
 
     if (geometry.IsNotNull())
     {
-      mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
+      mitk::BoundingBox::BoundsArrayType bounds = geometry->GetBounds();
 
       mitk::Point3D cornerPoint1InIndexCoordinates;
       cornerPoint1InIndexCoordinates[0] = bounds[0];
       cornerPoint1InIndexCoordinates[1] = bounds[2];
       cornerPoint1InIndexCoordinates[2] = bounds[4];
 
       mitk::Point3D cornerPoint2InIndexCoordinates;
       cornerPoint2InIndexCoordinates[0] = bounds[1];
       cornerPoint2InIndexCoordinates[1] = bounds[3];
       cornerPoint2InIndexCoordinates[2] = bounds[5];
 
       if (!geometry->GetImageGeometry())
       {
         cornerPoint1InIndexCoordinates[0] += 0.5;
         cornerPoint1InIndexCoordinates[1] += 0.5;
         cornerPoint1InIndexCoordinates[2] += 0.5;
         cornerPoint2InIndexCoordinates[0] -= 0.5;
         cornerPoint2InIndexCoordinates[1] -= 0.5;
         cornerPoint2InIndexCoordinates[2] -= 0.5;
       }
 
       mitk::Point3D crossPositionInWorldCoordinates = m_IRenderWindowPart->GetSelectedPosition();
 
       mitk::Point3D cornerPoint1InWorldCoordinates;
       mitk::Point3D cornerPoint2InWorldCoordinates;
 
       geometry->IndexToWorld(cornerPoint1InIndexCoordinates, cornerPoint1InWorldCoordinates);
       geometry->IndexToWorld(cornerPoint2InIndexCoordinates, cornerPoint2InWorldCoordinates);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(true);
 
       m_Controls.m_XWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
       m_Controls.m_XWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
 
       m_Controls.m_XWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[0]);
       m_Controls.m_YWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[1]);
       m_Controls.m_ZWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[2]);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(false);
     }
 
     this->SetBorderColors();
 
   }
 }
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 c3b8f808e2..5fd2ad191b 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
@@ -1,1360 +1,1360 @@
 /*===================================================================
 
 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::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("Datamanager")==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())
   {
     mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
-    m_RedoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.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();
     mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
-    m_RedoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingGeometry.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->GetTimeSlicedGeometry()->UpdateInformation();
-    m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
+    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())
   {
     mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
-    m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.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();
     mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
-    m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingGeometry.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->GetTimeSlicedGeometry()->UpdateInformation();
-    m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
+    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::Geometry3D::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
     mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
-    m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
+    m_UndoPointsGeometryList.push_back(movingLandmarksGeometry.GetPointer());
 
     mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
     mitk::Geometry3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
-    m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(originalDataGeometry.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->GetTimeSlicedGeometry()->UpdateInformation();
+    m_MovingLandmarks->GetTimeGeometry()->Update();
 
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0);
     movingGeometry->Compose(matrix);
-    movingData->GetTimeSlicedGeometry()->UpdateInformation();
+    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::Geometry3D::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
     mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
     m_UndoPointsGeometryList.push_back(movingLandmarksGeometry.GetPointer());
 
     mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
     mitk::Geometry3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
     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->GetTimeSlicedGeometry()->UpdateInformation();
+    m_MovingLandmarks->GetTimeGeometry()->Update();
 
     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
     mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0);
     movingGeometry->Compose(matrix);
-    movingData->GetTimeSlicedGeometry()->UpdateInformation();
+    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::Geometry3D::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)
       {
         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)
       {
         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/QmitkRigidRegistrationSelectorView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.cpp
index fcca0f263c..7e44c926b8 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.cpp
@@ -1,773 +1,773 @@
 /*===================================================================
 
 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 "mitkImageTimeSelector.h"
 #include <QValidator>
 #include <vtkTransform.h>
 #include <vtkMatrix4x4.h>
 #include "mitkMatrixConvert.h"
 #include <qinputdialog.h>
 #include <qmessagebox.h>
 #include "QmitkLoadPresetDialog.h"
 #include <itkArray.h>
 #include "mitkRigidRegistrationPreset.h"
 
 #include "mitkProgressBar.h"
 
 #include "QmitkRigidRegistrationSelectorView.h"
 
 #include "QmitkTranslationTransformView.h"
 #include "QmitkScaleTransformView.h"
 #include "QmitkScaleLogarithmicTransformView.h"
 #include "QmitkAffineTransformView.h"
 #include "QmitkFixedCenterOfRotationAffineTransformView.h"
 #include "QmitkEuler3DTransformView.h"
 #include "QmitkCenteredEuler3DTransformView.h"
 #include "QmitkQuaternionRigidTransformView.h"
 #include "QmitkVersorTransformView.h"
 #include "QmitkVersorRigid3DTransformView.h"
 #include "QmitkScaleSkewVersor3DTransformView.h"
 #include "QmitkSimilarity3DTransformView.h"
 #include "QmitkRigid2DTransformView.h"
 #include "QmitkCenteredRigid2DTransformView.h"
 #include "QmitkEuler2DTransformView.h"
 #include "QmitkSimilarity2DTransformView.h"
 #include "QmitkCenteredSimilarity2DTransformView.h"
 
 #include "QmitkMeanSquaresMetricView.h"
 #include "QmitkNormalizedCorrelationMetricView.h"
 #include "QmitkGradientDifferenceMetricView.h"
 #include "QmitkKullbackLeiblerCompareHistogramMetricView.h"
 #include "QmitkCorrelationCoefficientHistogramMetricView.h"
 #include "QmitkMeanSquaresHistogramMetricView.h"
 #include "QmitkMutualInformationHistogramMetricView.h"
 #include "QmitkNormalizedMutualInformationHistogramMetricView.h"
 #include "QmitkMattesMutualInformationMetricView.h"
 #include "QmitkMeanReciprocalSquareDifferenceMetricView.h"
 #include "QmitkMutualInformationMetricView.h"
 #include "QmitkMatchCardinalityMetricView.h"
 #include "QmitkKappaStatisticMetricView.h"
 
 #include "QmitkExhaustiveOptimizerView.h"
 #include "QmitkGradientDescentOptimizerView.h"
 #include "QmitkQuaternionRigidTransformGradientDescentOptimizerView.h"
 #include "QmitkLBFGSBOptimizerView.h"
 #include "QmitkOnePlusOneEvolutionaryOptimizerView.h"
 #include "QmitkPowellOptimizerView.h"
 #include "QmitkFRPROptimizerView.h"
 #include "QmitkRegularStepGradientDescentOptimizerView.h"
 #include "QmitkVersorTransformOptimizerView.h"
 #include "QmitkAmoebaOptimizerView.h"
 #include "QmitkConjugateGradientOptimizerView.h"
 #include "QmitkLBFGSOptimizerView.h"
 #include "QmitkSPSAOptimizerView.h"
 #include "QmitkVersorRigid3DTransformOptimizerView.h"
 
 QmitkRigidRegistrationSelectorView::QmitkRigidRegistrationSelectorView(QWidget* parent, Qt::WindowFlags f ) : QWidget( parent, f ),
 m_FixedNode(NULL), m_FixedMaskNode(NULL), m_MovingNode(NULL), m_MovingMaskNode(NULL), m_FixedDimension(0), m_MovingDimension(0),
 m_StopOptimization(false), m_GeometryItkPhysicalToWorldTransform(NULL), m_GeometryWorldToItkPhysicalTransform(NULL),
 m_MovingGeometry(NULL), m_ImageGeometry(NULL)
 {
   m_Controls.setupUi(parent);
 
   this->AddTransform(new QmitkTranslationTransformView(this, f));
   this->AddTransform(new QmitkScaleTransformView(this, f));
   this->AddTransform(new QmitkScaleLogarithmicTransformView(this, f));
   this->AddTransform(new QmitkAffineTransformView(this, f));
   this->AddTransform(new QmitkFixedCenterOfRotationAffineTransformView(this, f));
   this->AddTransform(new QmitkEuler3DTransformView(this, f));
   this->AddTransform(new QmitkCenteredEuler3DTransformView(this, f));
   this->AddTransform(new QmitkQuaternionRigidTransformView(this, f));
   this->AddTransform(new QmitkVersorTransformView(this, f));
   this->AddTransform(new QmitkVersorRigid3DTransformView(this, f));
   this->AddTransform(new QmitkScaleSkewVersor3DTransformView(this, f));
   this->AddTransform(new QmitkSimilarity3DTransformView(this, f));
   this->AddTransform(new QmitkRigid2DTransformView(this, f));
   this->AddTransform(new QmitkCenteredRigid2DTransformView(this, f));
   this->AddTransform(new QmitkEuler2DTransformView(this, f));
   this->AddTransform(new QmitkSimilarity2DTransformView(this, f));
   this->AddTransform(new QmitkCenteredSimilarity2DTransformView(this, f));
 
   this->AddMetric(new QmitkMeanSquaresMetricView(this, f));
   this->AddMetric(new QmitkNormalizedCorrelationMetricView(this, f));
   this->AddMetric(new QmitkGradientDifferenceMetricView(this, f));
   this->AddMetric(new QmitkKullbackLeiblerCompareHistogramMetricView(this, f));
   this->AddMetric(new QmitkCorrelationCoefficientHistogramMetricView(this, f));
   this->AddMetric(new QmitkMeanSquaresHistogramMetricView(this, f));
   this->AddMetric(new QmitkMutualInformationHistogramMetricView(this, f));
   this->AddMetric(new QmitkNormalizedMutualInformationHistogramMetricView(this, f));
   this->AddMetric(new QmitkMattesMutualInformationMetricView(this, f));
   this->AddMetric(new QmitkMeanReciprocalSquareDifferenceMetricView(this, f));
   this->AddMetric(new QmitkMutualInformationMetricView(this, f));
   this->AddMetric(new QmitkMatchCardinalityMetricView(this, f));
   this->AddMetric(new QmitkKappaStatisticMetricView(this, f));
 
   this->AddOptimizer(new QmitkExhaustiveOptimizerView(this, f));
   this->AddOptimizer(new QmitkGradientDescentOptimizerView(this, f));
   this->AddOptimizer(new QmitkQuaternionRigidTransformGradientDescentOptimizerView(this, f));
   this->AddOptimizer(new QmitkLBFGSBOptimizerView(this, f));
   this->AddOptimizer(new QmitkOnePlusOneEvolutionaryOptimizerView(this, f));
   this->AddOptimizer(new QmitkPowellOptimizerView(this, f));
   this->AddOptimizer(new QmitkFRPROptimizerView(this, f));
   this->AddOptimizer(new QmitkRegularStepGradientDescentOptimizerView(this, f));
   this->AddOptimizer(new QmitkVersorTransformOptimizerView(this, f));
   this->AddOptimizer(new QmitkAmoebaOptimizerView(this, f));
   this->AddOptimizer(new QmitkConjugateGradientOptimizerView(this, f));
   this->AddOptimizer(new QmitkLBFGSOptimizerView(this, f));
   this->AddOptimizer(new QmitkSPSAOptimizerView(this, f));
   this->AddOptimizer(new QmitkVersorRigid3DTransformOptimizerView(this, f));
 
   m_Observer = mitk::RigidRegistrationObserver::New();
   m_Controls.m_TransformFrame->setEnabled(true);
   m_Controls.m_MetricFrame->setEnabled(true);
   m_Controls.m_OptimizerFrame->setEnabled(true);
   m_Controls.m_InterpolatorFrame->setEnabled(true);
 
   m_Controls.m_TransformFrame->hide();
   m_Controls.m_MetricFrame->hide();
   m_Controls.m_OptimizerFrame->hide();
   m_Controls.m_InterpolatorFrame->hide();
   m_Controls.m_TransformBox->setCurrentIndex(0);
   m_Controls.m_MetricBox->setCurrentIndex(0);
   m_Controls.m_OptimizerBox->setCurrentIndex(0);
   m_Controls.m_TransformWidgetStack->setCurrentIndex(0);
   m_Controls.m_MetricWidgetStack->setCurrentIndex(0);
   m_Controls.m_OptimizerWidgetStack->setCurrentIndex(0);
   /// and show the selected views
   this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
   this->MetricSelected(m_Controls.m_MetricBox->currentIndex());
   this->OptimizerSelected(m_Controls.m_OptimizerBox->currentIndex());
 
 
   //// create connections
   connect( m_Controls.m_TransformGroup, SIGNAL(clicked(bool)), m_Controls.m_TransformFrame, SLOT(setVisible(bool)));
   connect( m_Controls.m_TransformBox, SIGNAL(activated(int)), m_Controls.m_TransformWidgetStack, SLOT(setCurrentIndex(int)));
   connect( m_Controls.m_TransformBox, SIGNAL(activated(int)), this, SLOT(TransformSelected(int)));
   connect( m_Controls.m_MetricBox, SIGNAL(activated(int)), this, SLOT(MetricSelected(int)));
   connect( m_Controls.m_OptimizerBox, SIGNAL(activated(int)), this, SLOT(OptimizerSelected(int)));
   connect( m_Controls.m_MetricGroup, SIGNAL(clicked(bool)), m_Controls.m_MetricFrame, SLOT(setVisible(bool)));
   connect( m_Controls.m_MetricBox, SIGNAL(activated(int)), m_Controls.m_MetricWidgetStack, SLOT(setCurrentIndex(int)));
   connect( m_Controls.m_OptimizerGroup, SIGNAL(clicked(bool)), m_Controls.m_OptimizerFrame, SLOT(setVisible(bool)));
   connect( m_Controls.m_OptimizerBox, SIGNAL(activated(int)), m_Controls.m_OptimizerWidgetStack, SLOT(setCurrentIndex(int)));
   connect( m_Controls.m_InterpolatorGroup, SIGNAL(toggled(bool)), m_Controls.m_InterpolatorFrame, SLOT(setVisible(bool)));
 
   m_Preset = new mitk::RigidRegistrationPreset();
   m_Preset->LoadPreset();
 
   this->DoLoadRigidRegistrationPreset("AffineMutualInformationGradientDescent");
 }
 
 QmitkRigidRegistrationSelectorView::~QmitkRigidRegistrationSelectorView()
 {
 }
 
 /// this method starts the registration process
 void QmitkRigidRegistrationSelectorView::CalculateTransformation(unsigned int timestep)
 {
   if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
   {
     emit AddNewTransformationToUndoList();
 
     mitk::Image::Pointer fimage = dynamic_cast<mitk::Image*>(m_FixedNode->GetData())->Clone();
     mitk::Image::Pointer mimage = dynamic_cast<mitk::Image*>(m_MovingNode->GetData())->Clone();
     mitk::Image::Pointer mmimage = NULL;
     mitk::Image::Pointer fmimage = NULL;
     if (m_MovingMaskNode.IsNotNull())
     {
       mmimage = dynamic_cast<mitk::Image*>(m_MovingMaskNode->GetData());
     }
     if (m_FixedMaskNode.IsNotNull())
     {
       fmimage = dynamic_cast<mitk::Image*>(m_FixedMaskNode->GetData());
     }
 
     mitk::ImageTimeSelector::Pointer its = mitk::ImageTimeSelector::New();
 
     if(fimage->GetDimension()>3)
     {
       its->SetInput(fimage);
       its->SetTimeNr(timestep);
       its->Update();
       fimage = its->GetOutput();
     }
 
     if(mimage->GetDimension()>3)
     {
       its->SetInput(mimage);
       its->SetTimeNr(timestep);
       its->Update();
       mimage = its->GetOutput();
     }
 
     // Initial moving image geometry
     m_ImageGeometry = m_MovingNode->GetData()->GetGeometry()->Clone();
     std::cout << "Moving Image Geometry (IndexToWorldTransform)"  << std::endl;
     std::cout << m_ImageGeometry->GetIndexToWorldTransform()->GetMatrix();
     mitk::Geometry3D::TransformType::InputPointType center = m_ImageGeometry->GetIndexToWorldTransform()->GetCenter();
     std::cout << "center " << center[0] << " " << center[1] << " " << center[2]  << std::endl;
     mitk::Geometry3D::TransformType::OutputVectorType offset = m_ImageGeometry->GetIndexToWorldTransform()->GetOffset();
     std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2]  << std::endl;
     std::cout << std::endl;
 
     // Fixed image geometry
-    //     mitk::AffineGeometryFrame3D::Pointer m_FixedGeometryCopy = m_FixedNode->GetData()->GetGeometry()->Clone();
+    //     mitk::Geometry3D::Pointer m_FixedGeometryCopy = m_FixedNode->GetData()->GetGeometry()->Clone();
     //     std::cout << "Fixed Image Geometry (IndexToWorldTransform)"  << std::endl;
     //     std::cout << m_FixedGeometryCopy->GetIndexToWorldTransform()->GetMatrix();
     //     center = m_FixedGeometryCopy->GetIndexToWorldTransform()->GetCenter();
     //     std::cout << "center " << center[0] << " " << center[1] << " " << center[2]  << std::endl;
     //     offset = m_FixedGeometryCopy->GetIndexToWorldTransform()->GetOffset();
     //     std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2]  << std::endl;
     //     std::cout << std::endl;
 
     // Calculate the World to ITK-Physical transform for the moving image
     m_MovingGeometry = m_MovingNode->GetData()->GetGeometry();
 
     unsigned long size;
     size = m_MovingNodeChildren->Size();
     mitk::DataNode::Pointer childNode;
     for (unsigned long i = 0; i < size; ++i)
     {
       m_ChildNodes.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(m_MovingNodeChildren->GetElement(i), m_MovingNodeChildren->GetElement(i)->GetData()->GetGeometry()));
       m_ChildNodes2.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(m_MovingNodeChildren->GetElement(i), m_MovingNodeChildren->GetElement(i)->GetData()->GetGeometry()->Clone()));
     }
 
     m_GeometryWorldToItkPhysicalTransform = mitk::Geometry3D::TransformType::New();
     GetWorldToItkPhysicalTransform(m_MovingGeometry, m_GeometryWorldToItkPhysicalTransform.GetPointer());
 
     //     std::cout << "Moving Image: World to ITK-physical transform" << std::endl;
     //     std::cout << m_GeometryWorldToItkPhysicalTransform->GetMatrix();
     //     center = m_GeometryWorldToItkPhysicalTransform->GetCenter();
     //     std::cout << "center " << center[0] << " " << center[1] << " " << center[2]  << std::endl;
     //     offset = m_GeometryWorldToItkPhysicalTransform->GetOffset();
     //     std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2]  << std::endl;
     //     std::cout << std::endl;
 
     // Calculate the ITK-Physical to World transform for the fixed image
     m_GeometryItkPhysicalToWorldTransform = mitk::Geometry3D::TransformType::New();
     mitk::Geometry3D::TransformType::Pointer fixedWorld2Phys = mitk::Geometry3D::TransformType::New();
     GetWorldToItkPhysicalTransform(m_FixedNode->GetData()->GetGeometry(), fixedWorld2Phys.GetPointer());
     fixedWorld2Phys->GetInverse(m_GeometryItkPhysicalToWorldTransform);
 
     //     std::cout << "Fixed Image: ITK-physical to World transform" << std::endl;
     //     std::cout << m_GeometryItkPhysicalToWorldTransform->GetMatrix();
     //     center = m_GeometryItkPhysicalToWorldTransform->GetCenter();
     //     std::cout << "center " << center[0] << " " << center[1] << " " << center[2]  << std::endl;
     //     offset = m_GeometryItkPhysicalToWorldTransform->GetOffset();
     //     std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2]  << std::endl;
     //     std::cout << std::endl;
 
     // init callback
     itk::ReceptorMemberCommand<QmitkRigidRegistrationSelectorView>::Pointer command = itk::ReceptorMemberCommand<QmitkRigidRegistrationSelectorView>::New();
     command->SetCallbackFunction(this, &QmitkRigidRegistrationSelectorView::SetOptimizerValue);
     int observer = m_Observer->AddObserver( itk::AnyEvent(), command );
 
     std::vector<std::string> presets;
     // init registration method
     mitk::ImageRegistrationMethod::Pointer registration = mitk::ImageRegistrationMethod::New();
 
     registration->SetObserver(m_Observer);
     registration->SetInterpolator(m_Controls.m_InterpolatorBox->currentIndex());
     registration->SetReferenceImage(fimage);
     registration->SetInput(mimage);
     if (mmimage.IsNotNull())
     {
       registration->SetMovingMask(mmimage);
     }
     if (fmimage.IsNotNull())
     {
       registration->SetFixedMask(fmimage);
     }
 
     dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->SetFixedImage(dynamic_cast<mitk::Image*>(m_FixedNode->GetData()));
     dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
     registration->SetOptimizerScales(dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetScales());
     registration->SetTransform(dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetTransform());
 
     dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
     registration->SetMetric(dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->GetMetric());
 
     registration->SetOptimizer(dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->GetOptimizer());
 
     double time(0.0);
     double tstart(0.0);
     tstart = clock();
 
     try
     {
       registration->Update();
     }
     catch (itk::ExceptionObject e)
     {
       MITK_INFO << "Caught exception: "<<e.GetDescription();
       QMessageBox::information( this, "Registration exception", e.GetDescription());
       mitk::ProgressBar::GetInstance()->Progress(20);
     }
 
     time += clock() - tstart;
     time = time / CLOCKS_PER_SEC;
 
     //printOut of the Time
     MITK_INFO << "Registration Time: " << time;
 
     m_Observer->RemoveObserver(observer);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkRigidRegistrationSelectorView::SetFixedNode( mitk::DataNode * fixedNode )
 {
   m_FixedNode = fixedNode;
   m_Controls.m_TransformBox->setCurrentIndex(m_Controls.m_TransformBox->currentIndex());
 }
 
 void QmitkRigidRegistrationSelectorView::SetFixedDimension( int dimension )
 {
   m_FixedDimension = dimension;
 }
 
 void QmitkRigidRegistrationSelectorView::SetMovingNode( mitk::DataNode * movingNode )
 {
   m_MovingNode = movingNode;
   this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
 }
 
 void QmitkRigidRegistrationSelectorView::SetMovingDimension(int dimension )
 {
   m_MovingDimension = dimension;
 }
 
 // this is a callback function that retrieves the current transformation
 // parameters after every step of progress in the optimizer.
 // depending on the choosen transformation, we construct a vtktransform
 // that will be applied to the geometry of the moving image.
 // the values are delivered by mitkRigidRgistrationObserver.cpp
 void QmitkRigidRegistrationSelectorView::SetOptimizerValue( const itk::EventObject & )
 {
   if (m_StopOptimization)
   {
     m_Observer->SetStopOptimization(true);
     m_StopOptimization = false;
   }
 
   // retreive optimizer value for the current transformation
   double value = m_Observer->GetCurrentOptimizerValue();
 
   // retreive current parameterset of the transformation
   itk::Array<double> transformParams = m_Observer->GetCurrentTranslation();
 
   // init an empty affine transformation that will be filled with
   // the corresponding transformation parameters in the following
   vtkMatrix4x4* vtkmatrix = vtkMatrix4x4::New();
   vtkmatrix->Identity();
 
   // init a transform that will be initialized with the vtkmatrix later
   vtkTransform* vtktransform = vtkTransform::New();
 
   if (m_MovingNode.IsNotNull())
   {
     vtktransform = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->Transform(vtkmatrix, vtktransform, transformParams);
 
     // the retrieved transform goes from fixed to moving space.
     // invert the transform in order to go from moving to fixed space.
     vtkMatrix4x4* vtkmatrix_inv = vtkMatrix4x4::New();
     vtktransform->GetInverse(vtkmatrix_inv);
 
     // now adapt the moving geometry accordingly
     m_MovingGeometry->GetIndexToWorldTransform()->SetIdentity();
 
     // the next view lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
 
     // set moving image geometry to registration result
     m_MovingGeometry->SetIndexToWorldTransformByVtkMatrix(vtkmatrix_inv);
 
     /*std::cout << std::endl;
     std::cout << m_MovingGeometry->GetIndexToWorldTransform()->GetMatrix();
     mitk::Geometry3D::TransformType::OutputVectorType offset = m_MovingGeometry->GetIndexToWorldTransform()->GetOffset();
     std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2]  << std::endl;*/
 
 
 #if !defined(ITK_IMAGE_BEHAVES_AS_ORIENTED_IMAGE)
     // the next few lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
     // go to itk physical space before applying the registration result
     m_MovingGeometry->Compose(m_GeometryWorldToItkPhysicalTransform, 1);
 
     // right in the beginning, transform by initial moving image geometry
     m_MovingGeometry->Compose(m_ImageGeometry->GetIndexToWorldTransform(), 1);
 
     // in the end, go back to world space
     m_MovingGeometry->Compose(m_GeometryItkPhysicalToWorldTransform, 0);
 
 #else
     m_MovingGeometry->Compose(m_ImageGeometry->GetIndexToWorldTransform(), 1);
 #endif
 
     /*std::cout << std::endl << m_MovingGeometry->GetIndexToWorldTransform()->GetMatrix();
     offset = m_MovingGeometry->GetIndexToWorldTransform()->GetOffset();
     std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2]  << std::endl << std::endl;*/
 
     // now adapt all children geometries accordingly if children exist
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>::iterator iter2;
     mitk::DataNode::Pointer childNode;
     for( iter = m_ChildNodes.begin(); iter != m_ChildNodes.end(); iter++ )
     {
       childNode = (*iter).first;
       if (childNode.IsNotNull())
       {
         mitk::Geometry3D* childGeometry;
-        mitk::AffineGeometryFrame3D::Pointer childImageGeometry;
+        mitk::Geometry3D::Pointer childImageGeometry;
         // Calculate the World to ITK-Physical transform for the moving mask
         childGeometry = (*iter).second;
         iter2 = m_ChildNodes2.find(childNode);
         childImageGeometry = (*iter2).second;
 
         childGeometry->GetIndexToWorldTransform()->SetIdentity();
 
         // the next view lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
 
         // set moving mask geometry to registration result
         childGeometry->SetIndexToWorldTransformByVtkMatrix(vtkmatrix_inv);
 
 #if !defined(ITK_IMAGE_BEHAVES_AS_ORIENTED_IMAGE)
         // the next few lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
         // go to itk physical space before applying the registration result
         childGeometry->Compose(m_GeometryWorldToItkPhysicalTransform, 1);
 
         // right in the beginning, transform by initial moving image geometry
         childGeometry->Compose(childImageGeometry->GetIndexToWorldTransform(), 1);
 
         // in the end, go back to world space
         childGeometry->Compose(m_GeometryItkPhysicalToWorldTransform, 0);
 
 #else
         childGeometry->Compose(childImageGeometry->GetIndexToWorldTransform(), 1);
 #endif
       }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   emit OptimizerChanged(value);
 }
 
 /// this method is called whenever the combobox with the selectable transforms changes
 /// responsible for showing the selected transform parameters
 void QmitkRigidRegistrationSelectorView::TransformSelected( int transform )
 {
   if (m_FixedNode.IsNotNull())
   {
     dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->SetFixedImage(dynamic_cast<mitk::Image*>(m_FixedNode->GetData()));
   }
   if (m_MovingNode.IsNotNull())
   {
     dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
   }
   int numberOfTransformParameters = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->GetNumberOfTransformParameters();
   dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->SetNumberOfTransformParameters(numberOfTransformParameters);
 
   //set fixed height
   m_Controls.m_TransformWidgetStack->setFixedHeight( dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->minimumSizeHint().height() );
   this->OptimizerSelected(m_Controls.m_OptimizerWidgetStack->currentIndex());
 }
 
 /// this method is called whenever the combobox with the selectable metrics changes
 /// responsible for showing the selected metric parameters
 void QmitkRigidRegistrationSelectorView::MetricSelected( int metric )
 {
   if (m_FixedNode.IsNotNull())
   {
     dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->widget(metric))->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
   }
 
   //set fixed height
   m_Controls.m_MetricWidgetStack->setFixedHeight( dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->widget(metric))->minimumSizeHint().height() );
 }
 
 /// this method is called whenever the combobox with the selectable optimizers changes
 /// responsible for showing the selected optimizer parameters
 void QmitkRigidRegistrationSelectorView::OptimizerSelected( int optimizer )
 {
   int numberOfTransformParameters = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetNumberOfTransformParameters();
   dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->widget(optimizer))->SetNumberOfTransformParameters(numberOfTransformParameters);
 
   //set fixed height
   m_Controls.m_OptimizerWidgetStack->setFixedHeight( dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->widget(optimizer))->minimumSizeHint().height() );
 }
 
 void QmitkRigidRegistrationSelectorView::LoadRigidRegistrationParameter()
 {
   this->DoLoadRigidRegistrationParameter();
 }
 
 void QmitkRigidRegistrationSelectorView::DoLoadRigidRegistrationParameter()
 {
   std::map<std::string, itk::Array<double> > existingPresets;
   existingPresets = m_Preset->getTransformValuesPresets();
 
   std::map<std::string, itk::Array<double> >::iterator iter;
   std::list<std::string> presets;
   for( iter = existingPresets.begin(); iter != existingPresets.end(); iter++ )
   {
     presets.push_back( (*iter).first );
   }
   if (presets.empty())
   {
     QMessageBox::warning( NULL, "RigidRegistrationParameters.xml", "RigidRegistrationParameters.xml is empty/does not exist. There are no presets to select.");
     return;
   }
   presets.sort();
   // ask about the name to load a preset
   QmitkLoadPresetDialog dialog( this, 0, "Load Preset", presets ); // needs a QWidget as parent
   int dialogReturnValue = dialog.exec();
   if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
 
   this->DoLoadRigidRegistrationPreset(dialog.GetPresetName());
 }
 
 void QmitkRigidRegistrationSelectorView::DoLoadRigidRegistrationPreset(std::string presetName)
 {
   itk::Array<double> transformValues;
   transformValues = m_Preset->getTransformValues(presetName);
 
   m_Controls.m_TransformGroup->setChecked(true);
   m_Controls.m_TransformFrame->setVisible(true);
   m_Controls.m_TransformBox->setCurrentIndex((int)transformValues[0]);
   m_Controls.m_TransformWidgetStack->setCurrentIndex((int)transformValues[0]);
   this->TransformSelected((int)transformValues[0]);
   itk::Array<double> transformValuesForGUI;
   transformValuesForGUI.SetSize(transformValues.Size());
   transformValuesForGUI.fill(0);
   for (unsigned int i = 1; i < transformValues.Size(); i++)
   {
     transformValuesForGUI[i-1] = transformValues[i];
   }
   dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->SetTransformParameters(transformValuesForGUI);
 
   itk::Array<double> metricValues;
   metricValues = m_Preset->getMetricValues(presetName);
 
   m_Controls.m_MetricGroup->setChecked(true);
   m_Controls.m_MetricFrame->setVisible(true);
   m_Controls.m_MetricBox->setCurrentIndex((int)metricValues[0]);
   m_Controls.m_MetricWidgetStack->setCurrentIndex((int)metricValues[0]);
   this->MetricSelected((int)metricValues[0]);
   itk::Array<double> metricValuesForGUI;
   metricValuesForGUI.SetSize(metricValues.Size());
   metricValuesForGUI.fill(0);
   for (unsigned int i = 1; i < metricValues.Size(); i++)
   {
     metricValuesForGUI[i-1] = metricValues[i];
   }
   dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->SetMetricParameters(metricValuesForGUI);
 
   itk::Array<double> optimizerValues;
   optimizerValues = m_Preset->getOptimizerValues(presetName);
 
   m_Controls.m_OptimizerGroup->setChecked(true);
   m_Controls.m_OptimizerFrame->setVisible(true);
   m_Controls.m_OptimizerBox->setCurrentIndex((int)optimizerValues[0]);
   m_Controls.m_OptimizerWidgetStack->setCurrentIndex((int)optimizerValues[0]);
   this->OptimizerSelected((int)optimizerValues[0]);
   itk::Array<double> optimizerValuesForGUI;
   optimizerValuesForGUI.SetSize(optimizerValues.Size());
   optimizerValuesForGUI.fill(0);
   for (unsigned int i = 1; i < optimizerValues.Size(); i++)
   {
     optimizerValuesForGUI[i-1] = optimizerValues[i];
   }
   dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->SetOptimizerParameters(optimizerValuesForGUI);
 
   itk::Array<double> interpolatorValues;
   interpolatorValues = m_Preset->getInterpolatorValues(presetName);
 
   m_Controls.m_InterpolatorGroup->setChecked(true);
   m_Controls.m_InterpolatorFrame->setVisible(true);
   m_Controls.m_InterpolatorBox->setCurrentIndex((int)interpolatorValues[0]);
 }
 
 void QmitkRigidRegistrationSelectorView::SaveRigidRegistrationParameter()
 {
   this->DoSaveRigidRegistrationParameter();
 }
 
 
 void QmitkRigidRegistrationSelectorView::DoSaveRigidRegistrationParameter()
 {
   bool ok;
   QString text = QInputDialog::getText(this,
     "Save Parameter Preset", "Enter name for preset:", QLineEdit::Normal,
     QString::null, &ok );
   if ( ok )
   {
     std::map<std::string, itk::Array<double> > existingPresets;
     existingPresets = m_Preset->getTransformValuesPresets();
 
     std::map<std::string, itk::Array<double> >::iterator iter = existingPresets.find(std::string((const char*)text.toLatin1()));
     if (iter != existingPresets.end())
     {
       QMessageBox::critical( this, "Preset definition",
         "Presetname already exists.");
       return;
     }
     if (text.isEmpty())
     {
       QMessageBox::critical( this, "Preset definition",
         "Presetname has to be set.\n"
         "You have to enter a Presetname." );
       return;
     }
     itk::Array<double> transformValues;
     transformValues.SetSize(25);
     transformValues.fill(0);
     transformValues[0] = m_Controls.m_TransformBox->currentIndex();
 
     itk::Array<double> transformValuesFromGUI = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetTransformParameters();
     for (unsigned int i = 0; i < transformValuesFromGUI.Size(); i++)
     {
       transformValues[i+1] = transformValuesFromGUI[i];
     }
 
     std::map<std::string, itk::Array<double> > transformMap;
     transformMap = m_Preset->getTransformValuesPresets();
 
     transformMap[std::string((const char*)text.toLatin1())] = transformValues;
 
     itk::Array<double> metricValues;
     metricValues.SetSize(25);
     metricValues.fill(0);
     metricValues[0] = m_Controls.m_MetricBox->currentIndex();
     itk::Array<double> metricValuesFromGUI = dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->GetMetricParameters();
     for (unsigned int i = 0; i < metricValuesFromGUI.Size(); i++)
     {
       metricValues[i+1] = metricValuesFromGUI[i];
     }
 
     std::map<std::string, itk::Array<double> > metricMap;
     metricMap = m_Preset->getMetricValuesPresets();
 
     metricMap[std::string((const char*)text.toLatin1())] = metricValues;
 
     itk::Array<double> optimizerValues;
     optimizerValues.SetSize(25);
     optimizerValues.fill(0);
     optimizerValues[0] = m_Controls.m_OptimizerBox->currentIndex();
     itk::Array<double> optimizerValuesFromGUI = dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->GetOptimizerParameters();
     for (unsigned int i = 0; i < optimizerValuesFromGUI.Size(); i++)
     {
       optimizerValues[i+1] = optimizerValuesFromGUI[i];
     }
 
     std::map<std::string, itk::Array<double> > optimizerMap;
     optimizerMap = m_Preset->getOptimizerValuesPresets();
 
     optimizerMap[std::string((const char*)text.toLatin1())] = optimizerValues;
 
     itk::Array<double> interpolatorValues;
     interpolatorValues.SetSize(25);
     interpolatorValues.fill(0);
     interpolatorValues[0] = m_Controls.m_InterpolatorBox->currentIndex();
 
     std::map<std::string, itk::Array<double> > interpolatorMap;
     interpolatorMap = m_Preset->getInterpolatorValuesPresets();
 
     interpolatorMap[std::string((const char*)text.toLatin1())] = interpolatorValues;
 
     m_Preset->newPresets(transformMap, metricMap, optimizerMap, interpolatorMap);
 
   }
   else
   {
     // user pressed Cancel
   }
 }
 
 void QmitkRigidRegistrationSelectorView::StopOptimization(bool stopOptimization)
 {
   m_StopOptimization = stopOptimization;
 }
 
 int QmitkRigidRegistrationSelectorView::GetSelectedTransform()
 {
   return m_Controls.m_TransformBox->currentIndex();
 }
 
 void QmitkRigidRegistrationSelectorView::SetFixedMaskNode( mitk::DataNode * fixedMaskNode )
 {
   m_FixedMaskNode = fixedMaskNode;
   this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
 }
 
 void QmitkRigidRegistrationSelectorView::SetMovingMaskNode( mitk::DataNode * movingMaskNode )
 {
   m_MovingMaskNode = movingMaskNode;
   this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
 }
 
 void QmitkRigidRegistrationSelectorView::SetMovingNodeChildren(mitk::DataStorage::SetOfObjects::ConstPointer children)
 {
   m_MovingNodeChildren = children;
 }
 
 void QmitkRigidRegistrationSelectorView::AddTransform(QmitkRigidRegistrationTransformsGUIBase* transform)
 {
   m_Controls.m_TransformBox->addItem(transform->GetName());
   int i = 0;
   if (!dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(i)))
   {
     m_Controls.m_TransformWidgetStack->addWidget(transform);
     m_Controls.m_TransformWidgetStack->removeWidget(m_Controls.m_TransformWidgetStack->widget(i));
     transform->SetupUI(m_Controls.m_TransformWidgetStack->widget(i));
   }
   else
   {
     i = m_Controls.m_TransformWidgetStack->addWidget(transform);
     transform->SetupUI(m_Controls.m_TransformWidgetStack->widget(i));
   }
 }
 
 void QmitkRigidRegistrationSelectorView::AddMetric(QmitkRigidRegistrationMetricsGUIBase* metric)
 {
   m_Controls.m_MetricBox->addItem(metric->GetName());
   int i = 0;
   if (!dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->widget(i)))
   {
     m_Controls.m_MetricWidgetStack->addWidget(metric);
     m_Controls.m_MetricWidgetStack->removeWidget(m_Controls.m_MetricWidgetStack->widget(i));
     metric->SetupUI(m_Controls.m_MetricWidgetStack->widget(i));
   }
   else
   {
     i = m_Controls.m_MetricWidgetStack->addWidget(metric);
     metric->SetupUI(m_Controls.m_MetricWidgetStack->widget(i));
   }
 }
 
 void QmitkRigidRegistrationSelectorView::AddOptimizer(QmitkRigidRegistrationOptimizerGUIBase* optimizer)
 {
   m_Controls.m_OptimizerBox->addItem(optimizer->GetName());
   int i = 0;
   if (!dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->widget(i)))
   {
     m_Controls.m_OptimizerWidgetStack->addWidget(optimizer);
     m_Controls.m_OptimizerWidgetStack->removeWidget(m_Controls.m_OptimizerWidgetStack->widget(i));
     optimizer->SetupUI(m_Controls.m_OptimizerWidgetStack->widget(i));
   }
   else
   {
     i = m_Controls.m_OptimizerWidgetStack->addWidget(optimizer);
     optimizer->SetupUI(m_Controls.m_OptimizerWidgetStack->widget(i));
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.h b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.h
index 360158f87c..955fc12807 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.h
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.h
@@ -1,110 +1,110 @@
 /*===================================================================
 
 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 QmitkRigidRegistrationSelectorViewWidgetHIncluded
 #define QmitkRigidRegistrationSelectorViewWidgetHIncluded
 
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "ui_QmitkRigidRegistrationSelector.h"
 #include "qobject.h"
 #include <org_mitk_gui_qt_registration_Export.h>
 #include "QmitkRigidRegistrationTransformsGUIBase.h"
 #include "QmitkRigidRegistrationMetricsGUIBase.h"
 #include "QmitkRigidRegistrationOptimizerGUIBase.h"
 
 
 /*!
 * \brief Widget for rigid registration
 *
 * Displays options for rigid registration.
 */
 class REGISTRATION_EXPORT QmitkRigidRegistrationSelectorView : public QWidget
 {
   Q_OBJECT
 
 public:
 
   QmitkRigidRegistrationSelectorView( QWidget* parent = 0, Qt::WindowFlags f = 0 );
   ~QmitkRigidRegistrationSelectorView();
 
   signals:
     void TransformChanged();
     void OptimizerChanged(double value);
     void AddNewTransformationToUndoList();
 
   public slots:
     void SetFixedNode( mitk::DataNode * fixedNode );
     void SetFixedMaskNode(mitk::DataNode * fixedMaskNode );
     void SetFixedDimension( int dimension );
     void SetMovingNode( mitk::DataNode * movingNode );
     void SetMovingNodeChildren(mitk::DataStorage::SetOfObjects::ConstPointer children);
     void SetMovingMaskNode(mitk::DataNode * movingMaskNode );
     void SetMovingDimension(int dimension );
     int GetSelectedTransform();
     void CalculateTransformation(unsigned int timestep = 0);
     void StopOptimization(bool stopOptimization);
 
   protected slots:
     // this is a callback function that retrieves the current transformation
     // parameters after every step of progress in the optimizer.
     // depending on the choosen transformation, we construct a vtktransform
     // that will be applied to the geometry of the moving image.
     // the values are delivered by mitkRigidRgistrationObserver.cpp
     void SetOptimizerValue( const itk::EventObject & );
     /// this method is called whenever the combobox with the selectable transforms changes
     /// responsible for showing the selected transformparameters
     void TransformSelected( int transform );
     /// this method is called whenever the combobox with the selectable metrics changes
     /// responsible for showing the selected metricparameters
     void MetricSelected( int metric );
     /// this method is called whenever the combobox with the selectable optimizer changes
     /// responsible for showing the selected optimizerparameters
     void OptimizerSelected( int optimizer );
 
     void LoadRigidRegistrationParameter();
     void SaveRigidRegistrationParameter();
     //void LoadRigidRegistrationTestParameter();
     //void SaveRigidRegistrationTestParameter();
     void DoLoadRigidRegistrationParameter();
     void DoLoadRigidRegistrationPreset(std::string presetName);
     void DoSaveRigidRegistrationParameter();
     void AddTransform(QmitkRigidRegistrationTransformsGUIBase* transform);
     void AddMetric(QmitkRigidRegistrationMetricsGUIBase* metric);
     void AddOptimizer(QmitkRigidRegistrationOptimizerGUIBase* optimizer);
 
 protected:
 
   Ui::QmitkRigidRegistrationSelector m_Controls;
   mitk::DataNode::Pointer m_FixedNode;
   mitk::DataNode::Pointer m_FixedMaskNode;
   mitk::DataNode::Pointer m_MovingNode;
   mitk::DataNode::Pointer m_MovingMaskNode;
   int m_FixedDimension;
   int m_MovingDimension;
   bool m_StopOptimization;
   mitk::RigidRegistrationPreset* m_Preset;
   mitk::Geometry3D::TransformType::Pointer m_GeometryItkPhysicalToWorldTransform;
   mitk::Geometry3D::TransformType::Pointer m_GeometryWorldToItkPhysicalTransform;
   mitk::Geometry3D* m_MovingGeometry;
-  mitk::AffineGeometryFrame3D::Pointer m_ImageGeometry;
+  mitk::Geometry3D::Pointer m_ImageGeometry;
   mitk::RigidRegistrationObserver::Pointer m_Observer;
   mitk::DataStorage::SetOfObjects::ConstPointer m_MovingNodeChildren;
   std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> m_ChildNodes;
   std::map<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer> m_ChildNodes2;
 };
 
 #endif
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 d4e63c5d88..e5f78544e1 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
@@ -1,1409 +1,1409 @@
 /*===================================================================
 
 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 "QmitkRigidRegistrationView.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "qinputdialog.h"
 #include "qmessagebox.h"
 #include "qcursor.h"
 #include "qapplication.h"
 #include "qradiobutton.h"
 #include "qslider.h"
 #include "qtooltip.h"
 
 #include <vtkTransform.h>
 
 #include "mitkDataNodeObject.h"
 #include <mitkImageCast.h>
 
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 #include "mitkManualSegmentationToSurfaceFilter.h"
 #include <mitkSegmentationSink.h>
 
 #include <mitkImageStatisticsHolder.h>
 
 
 #include <itkBinaryThresholdImageFilter.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)
   {
 //    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.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);
           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_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("Datamanager")==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;
   }
 }
 
 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_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);
 
   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()));
 }
 
 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);
     }
 
     bool hasMask = 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::BoolProperty::Pointer isMaskProp = dynamic_cast<mitk::BoolProperty*>(children->GetElement(i)->GetProperty("binary"));
       if(isMaskProp.IsNotNull() && isMaskProp->GetValue() == true)
       {
         m_FixedMaskNode = children->GetElement(i);
         hasMask = true;
         this->CheckForMaskImages();
         break;
       }
     }
     if (!hasMask)
     {
       this->CheckForMaskImages();
       m_FixedMaskNode = NULL;
     }
 
     // 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);
 
     bool hasMask = false;
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     m_Controls.qmitkRigidRegistrationSelector1->SetMovingNodeChildren(children);
     unsigned long size;
     size = children->Size();
     for (unsigned long i = 0; i < size; ++i)
     {
       mitk::BoolProperty::Pointer isMaskProp = dynamic_cast<mitk::BoolProperty*>(children->GetElement(i)->GetProperty("binary"));
       if(isMaskProp.IsNotNull() && isMaskProp->GetValue() == true)
       {
         m_MovingMaskNode = children->GetElement(i);
         hasMask = true;
         this->CheckForMaskImages();
         break;
       }
     }
     if (!hasMask)
     {
       m_MovingMaskNode = NULL;
       this->CheckForMaskImages();
     }
   }
   else
   {
     m_Controls.m_MovingLabel->hide();
     m_Controls.TextLabelMoving->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(0)->Clone().GetPointer()));
   unsigned long size;
   mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
   size = children->Size();
   std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
   for (unsigned long i = 0; i < size; ++i)
   {
     childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
   }
   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;
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     size = children->Size();
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
     for (unsigned long i = 0; i < size; ++i)
     {
       childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
     }
     m_RedoChildGeometryList.push_back(childGeometries);
 
     movingData->SetGeometry(m_UndoGeometryList.back());
     m_UndoGeometryList.pop_back();
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> oldChildGeometries;
     oldChildGeometries = m_UndoChildGeometryList.back();
     m_UndoChildGeometryList.pop_back();
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
     for (unsigned long j = 0; j < size; ++j)
     {
       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()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
 
-    movingData->GetTimeSlicedGeometry()->UpdateInformation();
+    movingData->GetTimeGeometry()->Update();
     this->SetRedoEnabled(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   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;
     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
     size = children->Size();
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
     for (unsigned long i = 0; i < size; ++i)
     {
       childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
     }
     m_UndoChildGeometryList.push_back(childGeometries);
 
     movingData->SetGeometry(m_RedoGeometryList.back());
     m_RedoGeometryList.pop_back();
 
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> oldChildGeometries;
     oldChildGeometries = m_RedoChildGeometryList.back();
     m_RedoChildGeometryList.pop_back();
     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
     for (unsigned long j = 0; j < size; ++j)
     {
       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()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
 
-    movingData->GetTimeSlicedGeometry()->UpdateInformation();
+    movingData->GetTimeGeometry()->Update();
     this->SetUndoEnabled(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   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_UseFixedImageMask->isChecked())
   {
     m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(m_FixedMaskNode);
   }
   else
   {
     m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(NULL);
   }
   if (m_MovingMaskNode.IsNotNull() && m_Controls.m_UseMovingImageMask->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)
       {
         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)
       {
         nodeIt->Value()->SetVisibility(false);
       }
     }
   }
 }
 
 void QmitkRigidRegistrationView::CheckForMaskImages()
 {
   if (m_FixedMaskNode.IsNotNull())
   {
     m_Controls.m_UseFixedImageMask->show();
   }
   else
   {
     m_Controls.m_UseFixedImageMask->hide();
   }
   if (m_MovingMaskNode.IsNotNull())
   {
     m_Controls.m_UseMovingImageMask->show();
   }
   else
   {
     m_Controls.m_UseMovingImageMask->hide();
   }
 }
 
 void QmitkRigidRegistrationView::UseFixedMaskImageChecked(bool checked)
 {
   if (checked)
   {
     m_FixedMaskNode->SetVisibility(true);
   }
   else
   {
     m_FixedMaskNode->SetVisibility(false);
   }
 }
 
 void QmitkRigidRegistrationView::UseMovingMaskImageChecked(bool checked)
 {
   if (checked)
   {
     m_MovingMaskNode->SetVisibility(true);
   }
   else
   {
     m_MovingMaskNode->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();
 
 
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
index a659c3c1df..fd4f8096f7 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
@@ -1,196 +1,196 @@
 /*===================================================================
 
 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 "QmitkAutocropAction.h"
 
 #include "mitkAutoCropImageFilter.h"
 #include "mitkImageCast.h"
 #include "mitkRenderingManager.h"
 #include "mitkProgressBar.h"
 
 #include <itkConstantPadImageFilter.h>
 
 //needed for qApp
 #include <qcoreapplication.h>
 
 QmitkAutocropAction::QmitkAutocropAction()
 {
 }
 
 QmitkAutocropAction::~QmitkAutocropAction()
 {
 }
 
 void QmitkAutocropAction::Run( const QList<mitk::DataNode::Pointer> &selectedNodes )
 {
   foreach ( mitk::DataNode::Pointer node, selectedNodes )
   {
     if (node)
     {
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
       if (image.IsNull()) return;
 
       mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
       mitk::ProgressBar::GetInstance()->Progress(2);
 
       qApp->processEvents();
 
       mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
       cropFilter->SetInput( image );
       cropFilter->SetBackgroundValue( 0 );
       try
       {
         cropFilter->Update();
 
         image = cropFilter->GetOutput();
 
         if (image.IsNotNull())
         {
 
           if (image->GetDimension() == 4)
           {
             MITK_INFO << "4D AUTOCROP DOES NOT WORK AT THE MOMENT";
             throw "4D AUTOCROP DOES NOT WORK AT THE MOMENT";
 
             unsigned int timesteps = image->GetDimension(3);
             for (unsigned int i = 0; i < timesteps; i++)
             {
               mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
               imageTimeSelector->SetInput(image);
               imageTimeSelector->SetTimeNr(i);
               imageTimeSelector->UpdateLargestPossibleRegion();
 
               // We split a long nested code line into separate calls for debugging:
               mitk::ImageSource::OutputImageType *_3dSlice = imageTimeSelector->GetOutput();
               mitk::Image::Pointer _cropped3dSlice = this->IncreaseCroppedImageSize(_3dSlice);
 
               // +++ BUG +++ BUG +++ BUG +++ BUG +++ BUG +++ BUG +++ BUG +++
               void *_data = _cropped3dSlice->GetData();
 
               // <ToBeRemoved>
               // We write some stripes into the image
               if ((i & 1) == 0)
               {
               int depth = _cropped3dSlice->GetDimension(2);
               int height = _cropped3dSlice->GetDimension(1);
               int width = _cropped3dSlice->GetDimension(0);
 
               for (int z = 0; z < depth; ++z)
                 for (int y = 0; y < height; ++y)
                   for (int x = 0; x < width; ++x)
                     reinterpret_cast<unsigned char *>(_data)[(width * height * z) + (width * y) + x] = x & 1;
               // </ToBeRemoved>
               }
 
               image->SetVolume(_data, i);
             }
             node->SetData( image ); // bug fix 3145
           }
           else
           {
             node->SetData( this->IncreaseCroppedImageSize(image) ); // bug fix 3145
           }
           // Reinit node
           mitk::RenderingManager::GetInstance()->InitializeViews(
-            node->GetData()->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+            node->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
         }
       }
       catch(...)
       {
         MITK_ERROR << "Cropping image failed...";
       }
       mitk::ProgressBar::GetInstance()->Progress(8);
     }
     else
     {
       MITK_INFO << "   a NULL node selected";
     }
   }
 }
 
 mitk::Image::Pointer QmitkAutocropAction::IncreaseCroppedImageSize( mitk::Image::Pointer image )
 {
   typedef itk::Image< short, 3 > ImageType;
   typedef itk::Image< unsigned char, 3 > PADOutputImageType;
 
   ImageType::Pointer itkTransformImage = ImageType::New();
   mitk::CastToItkImage( image, itkTransformImage );
 
   typedef itk::ConstantPadImageFilter< ImageType, PADOutputImageType > PadFilterType;
   PadFilterType::Pointer padFilter = PadFilterType::New();
 
   unsigned long upperPad[3];
   unsigned long lowerPad[3];
   int borderLiner = 3;
 
   mitk::Point3D mitkOriginPoint;
   double origin[3];
   origin[0]=0;
   origin[1]=0;
   origin[2]=0;
   itkTransformImage->SetOrigin(origin);
 
   lowerPad[0]=borderLiner;
   lowerPad[1]=borderLiner;
   lowerPad[2]=borderLiner;
 
   upperPad[0]=borderLiner;
   upperPad[1]=borderLiner;
   upperPad[2]=borderLiner;
 
   padFilter->SetInput(itkTransformImage);
   padFilter->SetConstant(0);
   padFilter->SetPadUpperBound(upperPad);
   padFilter->SetPadLowerBound(lowerPad);
   padFilter->UpdateLargestPossibleRegion();
 
 
   mitk::Image::Pointer paddedImage = mitk::Image::New();
   paddedImage->InitializeByItk(padFilter->GetOutput());
   mitk::CastToMitkImage(padFilter->GetOutput(), paddedImage);
 
   //calculate translation according to padding to get the new origin
   mitk::Point3D paddedOrigin = image->GetGeometry()->GetOrigin();
   mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
   paddedOrigin[0] -= (borderLiner)*spacing[0];
   paddedOrigin[1] -= (borderLiner)*spacing[1];
   paddedOrigin[2] -= (borderLiner)*spacing[2];
 
   paddedImage->GetGeometry()->SetOrigin( paddedOrigin );
 
   return paddedImage;
 }
 
 void QmitkAutocropAction::SetSmoothed(bool /*smoothed*/)
 {
  //not needed
 }
 
 void QmitkAutocropAction::SetDecimated(bool /*decimated*/)
 {
   //not needed
 }
 
 void QmitkAutocropAction::SetDataStorage(mitk::DataStorage* /*dataStorage*/)
 {
   //not needed
 }
 
 void QmitkAutocropAction::SetFunctionality(berry::QtViewPart* /*functionality*/)
 {
   //not needed
 }
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
index 0883c55cf7..ad19056809 100644
--- a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
@@ -1,258 +1,258 @@
 /*===================================================================
 
 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 "QmitkSimulationView.h"
 #include <mitkIRenderingManager.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkSimulation.h>
 #include <mitkSimulationModel.h>
 
 QmitkSimulationView::QmitkSimulationView()
   : m_SelectionWasRemovedFromDataStorage(false),
     m_Timer(this)
 {
   this->GetDataStorage()->RemoveNodeEvent.AddListener(
     mitk::MessageDelegate1<QmitkSimulationView, const mitk::DataNode*>(this, &QmitkSimulationView::OnNodeRemovedFromDataStorage));
 
   connect(&m_Timer, SIGNAL(timeout()), this, SLOT(OnTimerTimeout()));
 }
 
 QmitkSimulationView::~QmitkSimulationView()
 {
   this->GetDataStorage()->RemoveNodeEvent.RemoveListener(
     mitk::MessageDelegate1<QmitkSimulationView, const mitk::DataNode*>(this, &QmitkSimulationView::OnNodeRemovedFromDataStorage));
 }
 
 void QmitkSimulationView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
 
   m_Controls.simulationComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.simulationComboBox->SetPredicate(mitk::NodePredicateDataType::New("Simulation"));
 
   m_Controls.stepsRecordedLabel->hide();
 
   connect(m_Controls.animateButton, SIGNAL(toggled(bool)), this, SLOT(OnAnimateButtonToggled(bool)));
   connect(m_Controls.recordButton, SIGNAL(toggled(bool)), this, SLOT(OnRecordButtonToggled(bool)));
   connect(m_Controls.resetButton, SIGNAL(clicked()), this, SLOT(OnResetButtonClicked()));
   connect(m_Controls.stepButton, SIGNAL(clicked()), this, SLOT(OnStepButtonClicked()));
   connect(m_Controls.simulationComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnSimulationComboBoxSelectionChanged(const mitk::DataNode*)));
   connect(m_Controls.dtSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnDTSpinBoxValueChanged(double)));
   connect(m_Controls.snapshotButton, SIGNAL(clicked()), this, SLOT(OnSnapshotButtonClicked()));
 
   if (m_Controls.simulationComboBox->GetSelectedNode().IsNotNull())
     this->OnSimulationComboBoxSelectionChanged(m_Controls.simulationComboBox->GetSelectedNode());
 }
 
 void QmitkSimulationView::OnAnimateButtonToggled(bool toggled)
 {
   if (this->SetSelectionAsCurrentSimulation())
   {
     mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
     sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
     sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
 
     rootNode->getContext()->setAnimate(toggled);
 
     if (toggled)
     {
       m_Controls.stepButton->setEnabled(false);
       m_Timer.start(0);
     }
   }
 
   if (!toggled)
   {
     m_Timer.stop();
     m_Controls.stepButton->setEnabled(true);
   }
 }
 
 void QmitkSimulationView::OnDTSpinBoxValueChanged(double value)
 {
   if (!this->SetSelectionAsCurrentSimulation())
     return;
 
   mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
   sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
 
   rootNode->setDt(std::max(0.0, value));
 }
 
 void QmitkSimulationView::OnNodeRemovedFromDataStorage(const mitk::DataNode* node)
 {
   if (m_Selection.IsNotNull() && m_Selection.GetPointer() == node)
     m_SelectionWasRemovedFromDataStorage = true;
 }
 
 void QmitkSimulationView::OnRecordButtonToggled(bool toggled)
 {
   if (!toggled)
   {
     if (m_Record.IsNotNull())
     {
       mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
       dataNode->SetData(m_Record);
       dataNode->SetName(m_Record->GetTimeSteps() == 1 ? "Snapshot" : "Record");
 
       this->GetDataStorage()->Add(dataNode, m_Selection);
-      mitk::RenderingManager::GetInstance()->InitializeViews(m_Record->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
+      mitk::RenderingManager::GetInstance()->InitializeViews(m_Record->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
 
       m_Record = NULL;
     }
 
     m_Controls.stepsRecordedLabel->hide();
     m_Controls.stepsRecordedLabel->setText("0 steps recorded");
   }
   else if (toggled)
   {
     m_Controls.stepsRecordedLabel->show();
   }
 }
 
 void QmitkSimulationView::OnResetButtonClicked()
 {
   if (!this->SetSelectionAsCurrentSimulation())
     return;
 
   if (m_Controls.recordButton->isChecked())
     m_Controls.recordButton->setChecked(false);
 
   mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
   sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
   sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
 
   m_Controls.dtSpinBox->setValue(simulation->GetDefaultDT());
   sofaSimulation->reset(rootNode.get());
 
   rootNode->setTime(0.0);
   sofaSimulation->updateContext(rootNode.get());
 
   simulation->GetDrawTool()->Reset();
 
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
 }
 
 void QmitkSimulationView::OnSimulationComboBoxSelectionChanged(const mitk::DataNode* node)
 {
   if (m_Controls.animateButton->isChecked())
     m_Controls.animateButton->setChecked(false);
 
   if (m_SelectionWasRemovedFromDataStorage)
   {
     m_SelectionWasRemovedFromDataStorage = false;
     m_Selection = NULL;
   }
 
   if (m_Controls.recordButton->isChecked())
     m_Controls.recordButton->setChecked(false);
 
   if (node != NULL)
   {
     m_Selection = m_Controls.simulationComboBox->GetSelectedNode();
     mitk::Simulation* simulation = static_cast<mitk::Simulation*>(m_Selection->GetData());
 
     m_Controls.sceneGroupBox->setEnabled(true);
     m_Controls.snapshotButton->setEnabled(true);
 
     simulation->SetAsActiveSimulation();
     m_Controls.dtSpinBox->setValue(simulation->GetDefaultDT());
   }
   else
   {
     m_Selection = NULL;
 
     m_Controls.sceneGroupBox->setEnabled(false);
     m_Controls.snapshotButton->setEnabled(false);
 
     mitk::Simulation::SetActiveSimulation(NULL);
     m_Controls.dtSpinBox->setValue(0.0);
   }
 }
 
 void QmitkSimulationView::OnSnapshotButtonClicked()
 {
   if (!this->SetSelectionAsCurrentSimulation())
     return;
 
   mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
 
   mitk::Surface::Pointer snapshot = simulation->TakeSnapshot();
 
   if (snapshot.IsNull())
     return;
 
   mitk::DataNode::Pointer snapshotDataNode = mitk::DataNode::New();
   snapshotDataNode->SetData(snapshot);
   snapshotDataNode->SetName("Snapshot");
 
   this->GetDataStorage()->Add(snapshotDataNode, m_Selection);
 }
 
 void QmitkSimulationView::OnStepButtonClicked()
 {
   if (!this->SetSelectionAsCurrentSimulation())
     return;
 
   mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
   sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
   sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
 
   simulation->GetDrawTool()->Reset();
 
   sofaSimulation->animate(rootNode.get(), rootNode->getDt());
 
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
 
   if (m_Controls.recordButton->isChecked())
   {
     if (m_Record.IsNull())
       m_Record = mitk::Surface::New();
 
     if (simulation->AppendSnapshot(m_Record))
     {
       unsigned int numSteps = m_Record->GetTimeSteps();
       QString plural = numSteps != 1 ? "s" : "";
 
       m_Controls.stepsRecordedLabel->setText(QString("%1 step%2 recorded").arg(numSteps).arg(plural));
     }
     else if (m_Record->GetTimeSteps() == 1)
     {
       m_Record = NULL;
     }
   }
 }
 
 void QmitkSimulationView::SetFocus()
 {
   m_Controls.animateButton->setFocus();
 }
 
 bool QmitkSimulationView::SetSelectionAsCurrentSimulation() const
 {
   if (m_Selection.IsNotNull())
   {
     static_cast<mitk::Simulation*>(m_Selection->GetData())->SetAsActiveSimulation();
     return true;
   }
 
   return false;
 }
 
 void QmitkSimulationView::OnTimerTimeout()
 {
   this->OnStepButtonClicked();
 }
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
index 17332a58d4..674a9f6ca6 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
@@ -1,472 +1,471 @@
 /*===================================================================
 
 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 "QmitkStdMultiWidgetEditor.h"
 
 #include <berryUIException.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPartListener.h>
 
 #include <QWidget>
 
 #include <mitkColorProperty.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkDataStorageEditorInput.h>
 #include <mitkIDataStorageService.h>
 
 #include <QmitkMouseModeSwitcher.h>
 #include <QmitkStdMultiWidget.h>
 
 #include <mbilogo.h>
 
 class QmitkStdMultiWidgetEditorPrivate
 {
 public:
 
   QmitkStdMultiWidgetEditorPrivate();
   ~QmitkStdMultiWidgetEditorPrivate();
 
   QmitkStdMultiWidget* m_StdMultiWidget;
   QmitkMouseModeSwitcher* m_MouseModeToolbar;
   std::string m_FirstBackgroundColor;
   std::string m_SecondBackgroundColor;
   bool m_MenuWidgetsEnabled;
   berry::IPartListener::Pointer m_PartListener;
 
   QHash<QString, QmitkRenderWindow*> m_RenderWindows;
 
 };
 
 struct QmitkStdMultiWidgetPartListener : public berry::IPartListener
 {
   berryObjectMacro(QmitkStdMultiWidgetPartListener)
 
   QmitkStdMultiWidgetPartListener(QmitkStdMultiWidgetEditorPrivate* dd)
     : d(dd)
   {}
 
   Events::Types GetPartEventTypes() const
   {
     return Events::CLOSED | Events::HIDDEN | Events::VISIBLE;
   }
 
   void PartClosed (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->RemovePlanesFromDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartHidden (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->RemovePlanesFromDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartVisible (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->AddPlanesToDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(true);
       }
     }
   }
 
 private:
 
   QmitkStdMultiWidgetEditorPrivate* const d;
 
 };
 
 QmitkStdMultiWidgetEditorPrivate::QmitkStdMultiWidgetEditorPrivate()
   : m_StdMultiWidget(0), m_MouseModeToolbar(0)
   , m_MenuWidgetsEnabled(false)
   , m_PartListener(new QmitkStdMultiWidgetPartListener(this))
 {}
 
 QmitkStdMultiWidgetEditorPrivate::~QmitkStdMultiWidgetEditorPrivate()
 {
 }
 
 const std::string QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget";
 
 QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor()
   : d(new QmitkStdMultiWidgetEditorPrivate)
 {
 }
 
 QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor()
 {
   this->GetSite()->GetPage()->RemovePartListener(d->m_PartListener);
 }
 
 QmitkStdMultiWidget* QmitkStdMultiWidgetEditor::GetStdMultiWidget()
 {
   return d->m_StdMultiWidget;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   if (d->m_StdMultiWidget) return d->m_StdMultiWidget->GetRenderWindow1();
   return 0;
 }
 
 QHash<QString, QmitkRenderWindow *> QmitkStdMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   return d->m_RenderWindows;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetQmitkRenderWindow(const QString &id) const
 {
   static bool alreadyWarned = false;
 
   if(!alreadyWarned)
   {
     MITK_WARN(id == "transversal") << "QmitkStdMultiWidgetEditor::GetRenderWindow(\"transversal\") is deprecated. Use \"axial\" instead.";
     alreadyWarned = true;
   }
 
   if (d->m_RenderWindows.contains(id))
     return d->m_RenderWindows[id];
 
   return 0;
 }
 
 mitk::Point3D QmitkStdMultiWidgetEditor::GetSelectedPosition(const QString & /*id*/) const
 {
   return d->m_StdMultiWidget->GetCrossPosition();
 }
 
 void QmitkStdMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D &pos, const QString &/*id*/)
 {
   d->m_StdMultiWidget->MoveCrossToPosition(pos);
 }
 
 void QmitkStdMultiWidgetEditor::EnableDecorations(bool enable, const QStringList &decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_BORDER))
   {
     enable ? d->m_StdMultiWidget->EnableColoredRectangles()
            : d->m_StdMultiWidget->DisableColoredRectangles();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_LOGO))
   {
     enable ? d->m_StdMultiWidget->EnableDepartmentLogo()
            : d->m_StdMultiWidget->DisableDepartmentLogo();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     d->m_StdMultiWidget->ActivateMenuWidget(enable);
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_BACKGROUND))
   {
     enable ? d->m_StdMultiWidget->EnableGradientBackground()
            : d->m_StdMultiWidget->DisableGradientBackground();
   }
 }
 
 bool QmitkStdMultiWidgetEditor::IsDecorationEnabled(const QString &decoration) const
 {
   if (decoration == DECORATION_BORDER)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_LOGO)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_MENU)
   {
     return d->m_StdMultiWidget->IsMenuWidgetEnabled();
   }
   else if (decoration == DECORATION_BACKGROUND)
   {
     return d->m_StdMultiWidget->GetGradientBackgroundFlag();
   }
   return false;
 }
 
 QStringList QmitkStdMultiWidgetEditor::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_BORDER << DECORATION_LOGO << DECORATION_MENU << DECORATION_BACKGROUND;
   return decorations;
 }
 
 mitk::SlicesRotator* QmitkStdMultiWidgetEditor::GetSlicesRotator() const
 {
   return d->m_StdMultiWidget->GetSlicesRotator();
 }
 
 mitk::SlicesSwiveller* QmitkStdMultiWidgetEditor::GetSlicesSwiveller() const
 {
   return d->m_StdMultiWidget->GetSlicesSwiveller();
 }
 
 void QmitkStdMultiWidgetEditor::EnableSlicingPlanes(bool enable)
 {
   d->m_StdMultiWidget->SetWidgetPlanesVisibility(enable);
 }
 
 bool QmitkStdMultiWidgetEditor::IsSlicingPlanesEnabled() const
 {
   mitk::DataNode::Pointer node = this->d->m_StdMultiWidget->GetWidgetPlane1();
   if (node.IsNotNull())
   {
     bool visible = false;
     node->GetVisibility(visible, 0);
     return visible;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkStdMultiWidgetEditor::EnableLinkedNavigation(bool enable)
 {
   enable ? d->m_StdMultiWidget->EnableNavigationControllerEventListening()
          : d->m_StdMultiWidget->DisableNavigationControllerEventListening();
 }
 
 bool QmitkStdMultiWidgetEditor::IsLinkedNavigationEnabled() const
 {
   return d->m_StdMultiWidget->IsCrosshairNavigationEnabled();
 }
 
 void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (d->m_StdMultiWidget == 0)
   {
     QHBoxLayout* layout = new QHBoxLayout(parent);
     layout->setContentsMargins(0,0,0,0);
 
     if (d->m_MouseModeToolbar == NULL)
     {
       d->m_MouseModeToolbar = new QmitkMouseModeSwitcher(parent); // delete by Qt via parent
       layout->addWidget(d->m_MouseModeToolbar);
     }
 
     d->m_StdMultiWidget = new QmitkStdMultiWidget(parent);
 
     d->m_RenderWindows.insert("transversal", d->m_StdMultiWidget->GetRenderWindow1());
     d->m_RenderWindows.insert("axial", d->m_StdMultiWidget->GetRenderWindow1());
     d->m_RenderWindows.insert("sagittal", d->m_StdMultiWidget->GetRenderWindow2());
     d->m_RenderWindows.insert("coronal", d->m_StdMultiWidget->GetRenderWindow3());
     d->m_RenderWindows.insert("3d", d->m_StdMultiWidget->GetRenderWindow4());
 
     d->m_MouseModeToolbar->setMouseModeSwitcher( d->m_StdMultiWidget->GetMouseModeSwitcher() );
     connect( d->m_MouseModeToolbar, SIGNAL( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ),
       d->m_StdMultiWidget, SLOT( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ) );
 
     layout->addWidget(d->m_StdMultiWidget);
 
     mitk::DataStorage::Pointer ds = this->GetDataStorage();
 
     // Tell the multiWidget which (part of) the tree to render
     d->m_StdMultiWidget->SetDataStorage(ds);
 
     // Initialize views as axial, sagittal, coronar to all data objects in DataStorage
     // (from top-left to bottom)
-    mitk::TimeSlicedGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
+    mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
     mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
     // Initialize bottom-right view as 3D view
     d->m_StdMultiWidget->GetRenderWindow4()->GetRenderer()->SetMapperID(
       mitk::BaseRenderer::Standard3D );
 
     // Enable standard handler for levelwindow-slider
     d->m_StdMultiWidget->EnableStandardLevelWindow();
 
     // Add the displayed views to the tree to see their positions
     // in 2D and 3D
     d->m_StdMultiWidget->AddDisplayPlaneSubTree();
 
     d->m_StdMultiWidget->EnableNavigationControllerEventListening();
 
     // Store the initial visibility status of the menu widget.
     d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
 
     this->GetSite()->GetPage()->AddPartListener(d->m_PartListener);
 
     berry::IPreferences::Pointer prefs = this->GetPreferences();
     this->OnPreferencesChanged(dynamic_cast<berry::IBerryPreferences*>(prefs.GetPointer()));
 
     this->RequestUpdate();
   }
 }
 
 void QmitkStdMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   // Enable change of logo. If no DepartmentLogo was set explicitly, MBILogo is used.
   // Set new department logo by prefs->Set("DepartmentLogo", "PathToImage");
 
   // If no logo was set for this plug-in specifically, walk the parent preference nodes
   // and lookup a logo value there.
 
   const berry::IPreferences* currentNode = prefs;
 
   while(currentNode)
   {
     std::vector<std::string> keys = currentNode->Keys();
 
     bool logoFound = false;
     for( std::size_t i = 0; i < keys.size(); ++i )
     {
       if( keys[i] == "DepartmentLogo")
       {
         std::string departmentLogoLocation = currentNode->Get("DepartmentLogo", "");
 
         if (departmentLogoLocation.empty())
         {
           d->m_StdMultiWidget->DisableDepartmentLogo();
         }
         else
         {
           // we need to disable the logo first, otherwise setting a new logo will have
           // no effect due to how mitkManufacturerLogo works...
           d->m_StdMultiWidget->DisableDepartmentLogo();
           d->m_StdMultiWidget->SetDepartmentLogoPath(departmentLogoLocation.c_str());
           d->m_StdMultiWidget->EnableDepartmentLogo();
         }
         logoFound = true;
         break;
       }
     }
 
     if (logoFound) break;
     currentNode = currentNode->Parent().GetPointer();
   }
 
   // preferences for gradient background
   float color = 255.0;
   QString firstColorName = QString::fromStdString (prefs->GetByteArray("first background color", ""));
   QColor firstColor(firstColorName);
   mitk::Color upper;
   if (firstColorName=="") // default values
   {
     upper[0] = 0.1;
     upper[1] = 0.1;
     upper[2] = 0.1;
   }
   else
   {
     upper[0] = firstColor.red() / color;
     upper[1] = firstColor.green() / color;
     upper[2] = firstColor.blue() / color;
   }
 
   QString secondColorName = QString::fromStdString (prefs->GetByteArray("second background color", ""));
   QColor secondColor(secondColorName);
   mitk::Color lower;
   if (secondColorName=="") // default values
   {
     lower[0] = 0.5;
     lower[1] = 0.5;
     lower[2] = 0.5;
   }
   else
   {
     lower[0] = secondColor.red() / color;
     lower[1] = secondColor.green() / color;
     lower[2] = secondColor.blue() / color;
   }
   d->m_StdMultiWidget->SetGradientBackgroundColors(upper, lower);
   d->m_StdMultiWidget->EnableGradientBackground();
 
   // Set preferences respecting zooming and padding
   bool constrainedZooming = prefs->GetBool("Use constrained zooming and padding", false);
 
   mitk::RenderingManager::GetInstance()->SetConstrainedPaddingZooming(constrainedZooming);
 
   mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
 
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
-
+  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // level window setting
   bool showLevelWindowWidget = prefs->GetBool("Show level/window widget", true);
   if (showLevelWindowWidget)
   {
     d->m_StdMultiWidget->EnableStandardLevelWindow();
   }
   else
   {
     d->m_StdMultiWidget->DisableStandardLevelWindow();
   }
 
   // mouse modes toolbar
   bool newMode = prefs->GetBool("PACS like mouse interaction", false);
   d->m_MouseModeToolbar->setVisible( newMode );
   d->m_StdMultiWidget->GetMouseModeSwitcher()->SetInteractionScheme( newMode ? mitk::MouseModeSwitcher::PACS : mitk::MouseModeSwitcher::MITK );
 }
 
 void QmitkStdMultiWidgetEditor::SetFocus()
 {
   if (d->m_StdMultiWidget != 0)
     d->m_StdMultiWidget->setFocus();
 }
 
 void QmitkStdMultiWidgetEditor::RequestActivateMenuWidget(bool on)
 {
   if (d->m_StdMultiWidget)
   {
     if (on)
     {
       d->m_StdMultiWidget->ActivateMenuWidget(d->m_MenuWidgetsEnabled);
     }
     else
     {
       d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
       d->m_StdMultiWidget->ActivateMenuWidget(false);
     }
   }
 }
 
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index 93a022b94d..20ebdc3d40 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,683 +1,683 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 // Blueberry
 #include <mitkIRenderingManager.h>
 #include <mitkIRenderWindowPart.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 
 // Qmitk
 #include "QmitkToFUtilView.h"
 #include <QmitkStdMultiWidget.h>
 #include <QmitkTextOverlay.h>
 
 // Qt
 #include <QMessageBox>
 #include <QString>
 
 //QT headers
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include <mitkToFDeviceFactoryManager.h>
 #include <mitkToFCameraDevice.h>
 #include <mitkCameraIntrinsicsProperty.h>
 
 //itk headers
 #include <itksys/SystemTools.hxx>
 
 // VTK
 #include <vtkCamera.h>
 
 // ITK
 #include <itkCommand.h>
 #include <mitkRenderingModeProperty.h>
 
 const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
 
 //Constructor
 QmitkToFUtilView::QmitkToFUtilView()
   : QmitkAbstractView()
   , m_Controls(NULL), m_MultiWidget( NULL )
   , m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
   , m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
   , m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
   , m_2DDisplayCount(0)
   , m_RealTimeClock(NULL)
   , m_StepsForFramerate(100)
   , m_2DTimeBefore(0.0)
   , m_2DTimeAfter(0.0)
   , m_CameraIntrinsics(NULL)
 {
   this->m_Frametimer = new QTimer(this);
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
 }
 
 //Destructor, specifically calling OnToFCameraStopped() and OnToFCammeraDiconnected()
 QmitkToFUtilView::~QmitkToFUtilView()
 {
   OnToFCameraStopped();
   OnToFCameraDisconnected();
 }
 
 //Createing the PartControl Signal-Slot principal
 void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkToFUtilViewControls;
     m_Controls->setupUi( parent );
 
     //Looking for Input and Defining reaction
     connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
 
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_SurfaceCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnSurfaceCheckboxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_KinectTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnKinectRGBTextureCheckBoxChecked(bool)) );
 
   }
 }
 
 //SetFocus-Method -> actually seting Focus to the Recorder
 void QmitkToFUtilView::SetFocus()
 {
   m_Controls->m_ToFRecorderWidget->setFocus();
 }
 
 //Activated-Method->Generating RenderWindow
 void QmitkToFUtilView::Activated()
 {
   //get the current RenderWindowPart or open a new one if there is none
   if(this->GetRenderWindowPart(OPEN))
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
     if(linkedRenderWindowPart == 0)
     {
       MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(false);
     }
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
 
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
 
     this->UseToFVisibilitySettings(true);
 
     if (this->m_ToFCompositeFilter)
     {
       m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
     }
     if (this->GetDataStorage())
     {
       m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
     }
 
     if (this->m_ToFImageGrabber.IsNull())
     {
       m_Controls->m_ToFRecorderWidget->setEnabled(false);
       m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
       m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
       m_Controls->tofMeasurementWidget->setEnabled(false);
       m_Controls->SurfacePropertiesBox->setEnabled(false);
     }
   }
 }
 
 //ZomnnieView-Method -> Resetting GUI to default. Why not just QmitkToFUtilView()?!
 void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::Deactivated()
 {
 }
 
 void QmitkToFUtilView::Visible()
 {
 }
 
 //Reset of the ToFUtilView
 void QmitkToFUtilView::Hidden()
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::OnToFCameraConnected()
 {
   MITK_DEBUG <<"OnToFCameraConnected";
   this->m_2DDisplayCount = 0;
 
   this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
 
   // initialize surface generation
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
 
   // initialize ToFImageRecorder and ToFRecorderWidget
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
   m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
   m_Controls->m_ToFRecorderWidget->setEnabled(true);
   m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
 
   // initialize ToFCompositeFilterWidget
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   if (this->m_ToFCompositeFilter)
   {
     m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
   }
   if (this->GetDataStorage())
   {
     m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
   }
 
   // initialize measurement widget
   m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
 
   this->m_RealTimeClock = mitk::RealTimeClock::New();
   this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkToFUtilView::ResetGUIToDefault()
 {
   if(this->GetRenderWindowPart())
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
     if(linkedRenderWindowPart == 0)
     {
       MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(true);
     }
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
 
     this->UseToFVisibilitySettings(false);
 
     //global reinit
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
     this->RequestRenderWindowUpdate();
   }
 }
 
 void QmitkToFUtilView::OnToFCameraDisconnected()
 {
   m_Controls->m_ToFRecorderWidget->OnStop();
   m_Controls->m_ToFRecorderWidget->setEnabled(false);
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->tofMeasurementWidget->setEnabled(false);
   m_Controls->SurfacePropertiesBox->setEnabled(false);
   //clean up measurement widget
   m_Controls->tofMeasurementWidget->CleanUpWidget();
 }
 
 void QmitkToFUtilView::OnKinectAcquisitionModeChanged()
 {
   if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
   {
     if (m_SelectedCamera.contains("Kinect"))
     {
       if (m_ToFImageGrabber->GetBoolProperty("RGB"))
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
         this->m_ToFDistanceImageToSurfaceFilter->SetInput(3,this->m_ToFImageGrabber->GetOutput(3));
       }
       else if (m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
         this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
       }
     }
     this->UseToFVisibilitySettings(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStarted()
 {
   if (m_ToFImageGrabber.IsNotNull())
   {
     // initialize camera intrinsics
     if (this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))
     {
       m_CameraIntrinsics = dynamic_cast<mitk::CameraIntrinsicsProperty*>(this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))->GetValue();
       MITK_INFO << m_CameraIntrinsics->ToString();
     }
     else
     {
       m_CameraIntrinsics = NULL;
       MITK_ERROR << "No camera intrinsics were found!";
     }
 
     // set camera intrinsics
     if ( m_CameraIntrinsics.IsNotNull() )
     {
       this->m_ToFDistanceImageToSurfaceFilter->SetCameraIntrinsics(m_CameraIntrinsics);
     }
 
     // initial update of image grabber
     this->m_ToFImageGrabber->Update();
 
     this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
     this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
     this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
 
     // initial update of composite filter
     this->m_ToFCompositeFilter->Update();
     this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput();
     this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
 
     std::string rgbFileName;
     m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
 
     bool hasRGBImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasRGBImage",hasRGBImage);
 
     bool hasIntensityImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasIntensityImage",hasIntensityImage);
 
     bool hasAmplitudeImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasAmplitudeImage",hasAmplitudeImage);
 
     bool KinectReconstructionMode = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("KinectReconstructionMode",KinectReconstructionMode);
     if(KinectReconstructionMode)
     {
       //set the reconstruction mode for kinect
       this->m_ToFDistanceImageToSurfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::Kinect);
     }
 
     if (m_CameraIntrinsics.IsNotNull())
     {
       m_ToFDistanceImageToSurfaceFilter->SetCameraIntrinsics(m_CameraIntrinsics);
     }
 
     if(hasRGBImage || (rgbFileName!=""))
     {
       if(m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       }
       else
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
       }
     }
     else
     {
       this->m_RGBImageNode = NULL;
     }
 
     if(hasAmplitudeImage)
     {
       this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
     }
 
     if(hasIntensityImage)
     {
       this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
       this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
     }
 
     //    if ((rgbFileName!="") || hasRGBImage)
     //    {
 
     //    }
     //    else
     //    {
 
 
     //    }
     //    this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
     //    this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
 
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
     this->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
     this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
 
     this->UseToFVisibilitySettings(true);
 
     m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
     // initialize visualization widget
     m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
     // set distance image to measurement widget
     m_Controls->tofMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
 
     this->m_Frametimer->start(0);
 
     m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
     m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
     m_Controls->tofMeasurementWidget->setEnabled(true);
     m_Controls->SurfacePropertiesBox->setEnabled(true);
 
     if (m_Controls->m_TextureCheckBox->isChecked())
     {
       OnTextureCheckBoxChecked(true);
     }
     if (m_Controls->m_KinectTextureCheckBox->isChecked())
     {
       OnKinectRGBTextureCheckBoxChecked(true);
     }
   }
   m_Controls->m_TextureCheckBox->setEnabled(true);
 }
 
 void QmitkToFUtilView::OnToFCameraStopped()
 {
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
   m_Controls->SurfacePropertiesBox->setEnabled(false);
 
   this->m_Frametimer->stop();
 }
 
 void QmitkToFUtilView::OnToFCameraSelected(const QString selected)
 {
   m_SelectedCamera = selected;
   if (selected.contains("O3D"))
   {
     MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
     this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
     this->m_Controls->m_TextureCheckBox->setEnabled(false);
     this->m_Controls->m_KinectTextureCheckBox->setEnabled(false);
     this->m_Controls->m_SurfaceCheckBox->setChecked(false);
     this->m_Controls->m_TextureCheckBox->setChecked(false);
     this->m_Controls->m_KinectTextureCheckBox->setChecked(false);
   }
   else
   {
     this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
     this->m_Controls->m_TextureCheckBox->setEnabled(true);
     this->m_Controls->m_KinectTextureCheckBox->setEnabled(true);
   }
 }
 
 void QmitkToFUtilView::OnSurfaceCheckboxChecked(bool checked)
 {
   if(checked)
   {
     //initialize the surface once
     MITK_DEBUG << "OnSurfaceCheckboxChecked true";
     this->m_SurfaceNode->SetData(this->m_Surface);
     this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
 
     this->m_ToFDistanceImageToSurfaceFilter->SetTriangulationThreshold( this->m_Controls->m_TriangulationThreshold->value() );
 
     //we need to initialize (reinit) the surface, to make it fit into the renderwindow
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
-          this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
+          this->m_Surface->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
 
     // correctly place the vtk camera for appropriate surface rendering
     vtkCamera* camera3d = GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera();
     //1m distance to camera should be a nice default value for most cameras
     camera3d->SetPosition(0,0,0);
     camera3d->SetViewUp(0,-1,0);
     camera3d->SetFocalPoint(0,0,1);
     if (this->m_CameraIntrinsics.IsNotNull())
     {
       // compute view angle from camera intrinsics
       camera3d->SetViewAngle(mitk::ToFProcessingCommon::CalculateViewAngle(m_CameraIntrinsics,m_ToFImageGrabber->GetCaptureWidth()));
     }
     else
     {
       camera3d->SetViewAngle(45);
     }
     camera3d->SetClippingRange(1, 10000);
   }
 }
 
 void QmitkToFUtilView::OnUpdateCamera()
 {
   //##### Code for surface #####
   if (m_Controls->m_SurfaceCheckBox->isChecked())
   {
     // update surface
     m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
 
     //if the user wants to see the texture, it has to be updated for every frame
     if(m_Controls->m_KinectTextureCheckBox->isChecked() && (m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
     {
       //remove the vtkScalarsToColors object, if there was one.
       this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(NULL);
       //set RGB-iamge as texture
       this->m_ToFSurfaceVtkMapper3D->SetTexture((this->m_ToFImageGrabber->GetOutput(3)->GetVtkImageData()));
     }
     else
     {
       //we have to delete the texture, if there was one.
       this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
       //get the colortransferfunction from the visualization widget
       this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction());
     }
     //update pipeline
     this->m_Surface->Update();
   }
   //##### End code for surface #####
   else
   {
     // update pipeline
     this->m_MitkDistanceImage->Update();
   }
 
   this->RequestRenderWindowUpdate();
 
   this->m_2DDisplayCount++;
   if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
   {
     this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
     MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter/1000);
     this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
   }
 }
 
 void QmitkToFUtilView::OnTextureCheckBoxChecked(bool checked)
 {
   if(m_SurfaceNode.IsNotNull())
   {
     if (checked)
     {
       this->m_SurfaceNode->SetBoolProperty("scalar visibility", true);
     }
     else
     {
       this->m_SurfaceNode->SetBoolProperty("scalar visibility", false);
     }
   }
 }
 
 void QmitkToFUtilView::OnKinectRGBTextureCheckBoxChecked(bool checked)
 {
   if((m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
   {
     if (checked)
     {
       //define the dimensions of the texture
       this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(0));
       this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(1));
     }
   }
 }
 
 void QmitkToFUtilView::OnChangeCoronalWindowOutput(int index)
 {
   this->OnToFCameraStopped();
   if(index == 0)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(false);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(true);
   }
   else if(index == 1)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(true);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(false);
   }
   this->RequestRenderWindowUpdate();
   this->OnToFCameraStarted();
 }
 
 mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
 {
 
   mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
   if (node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetData(data);
     node->SetName(nodeName);
     node->SetBoolProperty("binary",false);
     this->GetDataStorage()->Add(node);
   }
   else
   {
     node->SetData(data);
   }
   return node;
 }
 
 void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
 {
   //We need this property for every node.
   mitk::RenderingModeProperty::Pointer renderingModePropertyForTransferFunction = mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
   // set node properties
   if (m_DistanceImageNode.IsNotNull())
   {
     this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_AmplitudeImageNode.IsNotNull())
   {
     if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("RGB")))
     {
       this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
     else
     {
       this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     }
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_IntensityImageNode.IsNotNull())
   {
     if (m_SelectedCamera.contains("Kinect"))
     {
       this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
     else
     {
       this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
     }
   }
   if ((m_RGBImageNode.IsNotNull()))
   {
     if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("IR")))
     {
       this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
     else
     {
       this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
     }
   }
   // initialize images
   if (m_MitkDistanceImage.IsNotNull())
   {
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
-          this->m_MitkDistanceImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
+          this->m_MitkDistanceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
   }
   if(this->m_SurfaceNode.IsNotNull())
   {
     QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetQmitkRenderWindows();
     QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
     while (i.hasNext()){
       i.next();
       this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->GetRenderWindow()) );
     }
     this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
   }
   //disable/enable gradient background
   this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
 
   if((this->m_RGBImageNode.IsNotNull()))
   {
     bool RGBImageHasDifferentResolution = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("RGBImageHasDifferentResolution",RGBImageHasDifferentResolution);
     if(RGBImageHasDifferentResolution)
     {
       //update the display geometry by using the RBG image node. Only for renderwindow coronal
       mitk::RenderingManager::GetInstance()->InitializeView( GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow(), this->m_RGBImageNode->GetData()->GetGeometry() );
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
index 194aed4f4a..12546b3d8e 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 //Mitk
 #include <mitkDataNode.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 
 // Qmitk
 #include "UltrasoundSupport.h"
 #include <QTimer>
 
 // Qt
 #include <QMessageBox>
 
 // Ultrasound
 #include "mitkUSDevice.h"
 
 const std::string UltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
 
 void UltrasoundSupport::SetFocus()
 {
   m_Controls.m_AddDevice->setFocus();
 }
 
 void UltrasoundSupport::CreateQtPartControl( QWidget *parent )
 {
   m_Timer = new QTimer(this);
 
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
   connect( m_Controls.m_AddDevice, SIGNAL(clicked()), this, SLOT(OnClickedAddNewDevice()) ); // Change Widget Visibilities
   connect( m_Controls.m_AddDevice, SIGNAL(clicked()), this->m_Controls.m_NewVideoDeviceWidget, SLOT(CreateNewDevice()) ); // Init NewDeviceWidget
   connect( m_Controls.m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone()) ); // After NewDeviceWidget finished editing
   connect( m_Controls.m_BtnView, SIGNAL(clicked()), this, SLOT(OnClickedViewDevice()) );
   connect( m_Timer, SIGNAL(timeout()), this, SLOT(DisplayImage()));
   connect( m_Controls.crop_left, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
   connect( m_Controls.crop_right, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
   connect( m_Controls.crop_top, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
   connect( m_Controls.crop_bot, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
   //connect (m_Controls.m_ActiveVideoDevices, SIGNAL())
 
   // Initializations
   m_Controls.m_NewVideoDeviceWidget->setVisible(false);
   std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice)(" + mitk::USDevice::US_PROPKEY_ISACTIVE + "=true))";
   m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(mitk::USDevice::US_PROPKEY_LABEL ,filter);
 
   //UI initializations
   m_Controls.crop_left->setEnabled(false);
   m_Controls.crop_right->setEnabled(false);
   m_Controls.crop_bot->setEnabled(false);
   m_Controls.crop_top->setEnabled(false);
 
 
   m_Node = mitk::DataNode::New();
   m_Node->SetName("US Image Stream");
   this->GetDataStorage()->Add(m_Node);
 }
 
 void UltrasoundSupport::OnClickedAddNewDevice()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(true);
   m_Controls.m_DeviceManagerWidget->setVisible(false);
   m_Controls.m_AddDevice->setVisible(false);
   m_Controls.m_Headline->setText("Add New Device:");
 }
 
 void UltrasoundSupport::DisplayImage()
 {
   m_Device->UpdateOutputData(0);
   m_Node->SetData(m_Device->GetOutput());
   this->RequestRenderWindowUpdate();
 
   m_FrameCounter ++;
   if (m_FrameCounter == 10)
   {
     int nMilliseconds = m_Clock.restart();
     int fps = 10000.0f / (nMilliseconds );
     m_Controls.m_FramerateLabel->setText("Current Framerate: "+ QString::number(fps) +" FPS");
     m_FrameCounter = 0;
   }
 }
 
 void UltrasoundSupport::OnCropAreaChanged()
 {
 if (m_Device->GetDeviceClass()=="org.mitk.modules.us.USVideoDevice")
       {
       mitk::USVideoDevice::Pointer currentVideoDevice = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
 
       mitk::USDevice::USImageCropArea newArea;
       newArea.cropLeft = m_Controls.crop_left->value();
       newArea.cropTop = m_Controls.crop_top->value();
       newArea.cropRight = m_Controls.crop_right->value();
       newArea.cropBottom = m_Controls.crop_bot->value();
 
       //check enabled: if not we are in the initializing step and don't need to do anything
       //otherwise: update crop area
       if (m_Controls.crop_right->isEnabled())
         currentVideoDevice->SetCropArea(newArea);
 
       GlobalReinit();
       }
 else
       {
       MITK_WARN << "No USVideoDevice: Cannot Crop!";
   }
 }
 
 void UltrasoundSupport::OnClickedViewDevice()
 {
   m_FrameCounter = 0;
   // We use the activity state of the timer to determine whether we are currently viewing images
   if ( ! m_Timer->isActive() ) // Activate Imaging
   {
     //get device & set data node
     m_Device = m_Controls.m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
     if (m_Device.IsNull()){
       m_Timer->stop();
       return;
     }
     m_Device->Update();
     m_Node->SetData(m_Device->GetOutput());
 
     //start timer
     int interval = (1000 / m_Controls.m_FrameRate->value());
     m_Timer->setInterval(interval);
     m_Timer->start();
 
     //reinit view
     GlobalReinit();
 
     //change UI elements
     m_Controls.m_BtnView->setText("Stop Viewing");
     m_Controls.m_FrameRate->setEnabled(false);
     m_Controls.crop_left->setValue(m_Device->GetCropArea().cropLeft);
     m_Controls.crop_right->setValue(m_Device->GetCropArea().cropRight);
     m_Controls.crop_bot->setValue(m_Device->GetCropArea().cropBottom);
     m_Controls.crop_top->setValue(m_Device->GetCropArea().cropTop);
     m_Controls.crop_left->setEnabled(true);
     m_Controls.crop_right->setEnabled(true);
     m_Controls.crop_bot->setEnabled(true);
     m_Controls.crop_top->setEnabled(true);
   }
   else //deactivate imaging
   {
     //stop timer & release data
     m_Timer->stop();
     m_Node->ReleaseData();
     this->RequestRenderWindowUpdate();
 
     //change UI elements
     m_Controls.m_BtnView->setText("Start Viewing");
     m_Controls.m_FrameRate->setEnabled(true);
     m_Controls.crop_left->setEnabled(false);
     m_Controls.crop_right->setEnabled(false);
     m_Controls.crop_bot->setEnabled(false);
     m_Controls.crop_top->setEnabled(false);
   }
 }
 
 void UltrasoundSupport::OnNewDeviceWidgetDone()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(false);
   m_Controls.m_DeviceManagerWidget->setVisible(true);
   m_Controls.m_AddDevice->setVisible(true);
   m_Controls.m_Headline->setText("Connected Devices:");
 }
 
 void UltrasoundSupport::GlobalReinit()
 {
   // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
 
   // calculate bounding geometry of these nodes
-  mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
 
 UltrasoundSupport::UltrasoundSupport()
 {
   m_DevicePersistence = mitk::USDevicePersistence::New();
   m_DevicePersistence->RestoreLastDevices();
 }
 
 UltrasoundSupport::~UltrasoundSupport()
 {
   m_DevicePersistence->StoreCurrentDevices();
   m_Controls.m_DeviceManagerWidget->DisconnectAllDevices();
 }