diff --git a/Modules/DataTypesExt/src/mitkUnstructuredGrid.cpp b/Modules/DataTypesExt/src/mitkUnstructuredGrid.cpp
index bc9577bba7..82ea53d899 100644
--- a/Modules/DataTypesExt/src/mitkUnstructuredGrid.cpp
+++ b/Modules/DataTypesExt/src/mitkUnstructuredGrid.cpp
@@ -1,265 +1,265 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY 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);
+  this->Expand(t+1);
 
   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::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;
 }
 
 void mitk::UnstructuredGrid::Graft(const DataObject* data)
 {
   const UnstructuredGrid* grid = dynamic_cast<const UnstructuredGrid*>(data);
 
   if(grid == NULL)
     mitkThrow() << "Data object used to graft surface is not a mitk::Surface.";
 
   this->CopyInformation(data);
   m_GridSeries.clear();
 
   for (unsigned int i = 0; i < grid->m_GridSeries.size(); ++i)
   {
     m_GridSeries.push_back(vtkUnstructuredGrid::New());
     m_GridSeries.back()->DeepCopy(const_cast<mitk::UnstructuredGrid*>(grid)->GetVtkUnstructuredGrid(i));
   }
 }
 
 mitk::UnstructuredGrid::UnstructuredGrid() : m_CalculateBoundingBox( false )
 {
   this->InitializeEmpty();
 }
 
 mitk::UnstructuredGrid::UnstructuredGrid(const mitk::UnstructuredGrid &other) :
 BaseData(other),
 m_LargestPossibleRegion(other.m_LargestPossibleRegion),
 m_CalculateBoundingBox( other.m_CalculateBoundingBox )
 {
   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
     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
   //
   TimeGeometry* timeGeometry = GetTimeGeometry();
   if ( timeGeometry->CountTimeSteps() != m_GridSeries.size() )
   {
     itkExceptionMacro(<<"timeGeometry->CountTimeSteps() != 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 ];
     double bounds[ ] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
     if ( ( grid != 0 ) && ( grid->GetNumberOfCells() > 0 ) )
     {
 //      grid->Update(); //VTK6_TODO
       grid->ComputeBounds();
       grid->GetBounds( bounds );
     }
     mitk::BaseGeometry::Pointer g3d = timeGeometry->GetGeometryForTimeStep( i );
     assert( g3d.IsNotNull() );
     g3d->SetFloatBounds( bounds );
   }
   timeGeometry->Update();
 
   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(); //VTK6_TODO
     }
   }
   Superclass::Update();
 }
diff --git a/Modules/MapperExt/include/mitkUnstructuredGridMapper2D.h b/Modules/MapperExt/include/mitkUnstructuredGridMapper2D.h
index 7a7ac86004..ab8bb651bc 100644
--- a/Modules/MapperExt/include/mitkUnstructuredGridMapper2D.h
+++ b/Modules/MapperExt/include/mitkUnstructuredGridMapper2D.h
@@ -1,114 +1,114 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY 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 MitkPointSetSliceLMapper2D_H
 #define MitkPointSetSliceLMapper2D_H
 
 #include "mitkCommon.h"
 #include "MitkMapperExtExports.h"
 #include "mitkGLMapper.h"
 #include "mitkTransferFunction.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 
 class vtkPointSetSlicer;
 class vtkPlane;
 class vtkLookupTable;
 class vtkPointSet;
 class vtkScalarsToColors;
 class vtkPiecewiseFunction;
 class vtkAbstractMapper3D;
 
 namespace mitk
 {
 
 class BaseRenderer;
 
 /**
  * @brief OpenGL-based mapper to display a 2d cut through a poly data
  * OpenGL-based mapper to display a 2D cut through a poly data. The result is
  * normally a line. This class can be added to any data object, which is
  * rendered in 3D via a vtkPolyData.
  */
 class MITKMAPPEREXT_EXPORT UnstructuredGridMapper2D : public GLMapper
 {
 public:
 
     mitkClassMacro( UnstructuredGridMapper2D, GLMapper );
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /**
      * Renders a cut through a pointset by cutting trough the n-cells,
      * producing (n-1)-cells.
      * @param renderer the render to render in.
      */
     virtual void Paint( mitk::BaseRenderer* renderer );
 
     LocalStorageHandler<BaseLocalStorage> m_LSH;
 
 protected:
 
     UnstructuredGridMapper2D();
 
     virtual ~UnstructuredGridMapper2D();
 
     virtual void GenerateDataForRenderer(BaseRenderer*);
 
     /**
      * Determines, if the associated BaseData is mapped three-dimensionally (mapper-slot id 2)
      * with a class convertable to vtkAbstractMapper3D().
      * @returns NULL if it is not convertable or the appropriate Mapper otherwise
      */
     virtual vtkAbstractMapper3D* GetVtkAbstractMapper3D(BaseRenderer* renderer);
 
     /**
      * Determines the pointset object to be cut.
      * returns the pointset if possible, otherwise NULL.
      */
-    virtual vtkPointSet* GetVtkPointSet(BaseRenderer* renderer );
+    virtual vtkPointSet* GetVtkPointSet(BaseRenderer* renderer, int time = 0 );
 
     /**
      * Determines the LookupTable used by the associated vtkMapper.
      * returns the LUT if possible, otherwise NULL.
      */
     virtual vtkScalarsToColors* GetVtkLUT(BaseRenderer* renderer );
 
     /**
      * Checks if this mapper can be used to generate cuts through the associated
      * base data.
      * @return true if yes or false if not.
      */
     virtual bool IsConvertibleToVtkPointSet(BaseRenderer* renderer);
 
     vtkPlane* m_Plane;
     vtkPointSetSlicer* m_Slicer;
     vtkPointSet* m_VtkPointSet;
     vtkScalarsToColors* m_ScalarsToColors;
     vtkPiecewiseFunction* m_ScalarsToOpacity;
 
     mitk::ColorProperty::Pointer m_Color;
     mitk::IntProperty::Pointer m_LineWidth;
     mitk::BoolProperty::Pointer m_Outline;
     mitk::BoolProperty::Pointer m_ScalarVisibility;
     mitk::VtkScalarModeProperty::Pointer m_ScalarMode;
 };
 
 } // namespace mitk
 #endif /* MitkPointSetSliceLMapper2D_H */
diff --git a/Modules/MapperExt/src/mitkUnstructuredGridMapper2D.cpp b/Modules/MapperExt/src/mitkUnstructuredGridMapper2D.cpp
index db4b67c26c..557aef248b 100644
--- a/Modules/MapperExt/src/mitkUnstructuredGridMapper2D.cpp
+++ b/Modules/MapperExt/src/mitkUnstructuredGridMapper2D.cpp
@@ -1,574 +1,574 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include <mitkGL.h>
 #include "mitkUnstructuredGridMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkUnstructuredGrid.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkProperties.h"
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkVtkMapper3D.h"
 
 #include <vtkUnstructuredGrid.h>
 #include <vtkPlane.h>
 #include <vtkCellArray.h>
 #include <vtkLookupTable.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkLinearTransform.h>
 #include <vtkVolume.h>
 #include <vtkAssembly.h>
 #include <vtkVolumeProperty.h>
 #include <vtkAbstractMapper3D.h>
 #include <vtkAbstractVolumeMapper.h>
 #include <vtkScalarsToColors.h>
 #include <vtkPiecewiseFunction.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkProp3DCollection.h>
 
 #include "vtkPointSetSlicer.h"
 
 void mitk::UnstructuredGridMapper2D::GenerateDataForRenderer( mitk::BaseRenderer* renderer )
 {
 
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   if(needGenerateData)
   {
     ls->UpdateGenerateDataTime();
 
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     if ( node.IsNull() )
       return;
 
     if (!node->GetProperty(m_ScalarMode, "scalar mode"))
     {
       m_ScalarMode = mitk::VtkScalarModeProperty::New(0);
     }
 
     if (!node->GetProperty(m_ScalarVisibility, "scalar visibility"))
     {
       m_ScalarVisibility = mitk::BoolProperty::New(true);
     }
 
     if (!node->GetProperty(m_Outline, "outline polygons"))
     {
       m_Outline = mitk::BoolProperty::New(false);
     }
 
     if (!node->GetProperty(m_Color, "color"))
     {
       m_Color = mitk::ColorProperty::New(1.0f, 1.0f, 1.0f);
     }
 
     if (!node->GetProperty(m_LineWidth, "line width"))
     {
       m_LineWidth = mitk::IntProperty::New(1);
     }
 
   }
   mitk::BaseData::Pointer input = const_cast<mitk::BaseData*>( GetDataNode()->GetData() );
   assert( input );
 
   input->Update();
 
   if (m_VtkPointSet) m_VtkPointSet->UnRegister(0);
-  m_VtkPointSet = this->GetVtkPointSet(renderer);
+  m_VtkPointSet = this->GetVtkPointSet(renderer, this->GetTimestep());
   assert(m_VtkPointSet);
   m_VtkPointSet->Register(0);
 
   if (m_ScalarVisibility->GetValue())
   {
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     mitk::TransferFunctionProperty::Pointer transferFuncProp;
     node->GetProperty(transferFuncProp, "TransferFunction", renderer);
     if (transferFuncProp.IsNotNull())
     {
       mitk::TransferFunction::Pointer tf = transferFuncProp->GetValue();
       if (m_ScalarsToColors) m_ScalarsToColors->UnRegister(0);
       m_ScalarsToColors = static_cast<vtkScalarsToColors*>(tf->GetColorTransferFunction());
       m_ScalarsToColors->Register(0);
 
       if (m_ScalarsToOpacity) m_ScalarsToOpacity->UnRegister(0);
       m_ScalarsToOpacity = tf->GetScalarOpacityFunction();
       m_ScalarsToOpacity->Register(0);
     }
     else
     {
       if (m_ScalarsToColors) m_ScalarsToColors->UnRegister(0);
       m_ScalarsToColors = this->GetVtkLUT(renderer);
       assert(m_ScalarsToColors);
       m_ScalarsToColors->Register(0);
 
       float opacity;
       node->GetOpacity(opacity, renderer);
       if (m_ScalarsToOpacity) m_ScalarsToOpacity->UnRegister(0);
       m_ScalarsToOpacity = vtkPiecewiseFunction::New();
       double range[2];
       m_VtkPointSet->GetScalarRange(range);
       m_ScalarsToOpacity->AddSegment(range[0], opacity, range[1], opacity);
     }
   }
 }
 
 void mitk::UnstructuredGridMapper2D::Paint( mitk::BaseRenderer* renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if(!visible) return;
 
   vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform();
   vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
 
   PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
 
   Point3D point;
   Vector3D normal;
 
   if(worldPlaneGeometry.IsNotNull())
   {
     // set up vtkPlane according to worldGeometry
     point=worldPlaneGeometry->GetOrigin();
     normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
     m_Plane->SetTransform((vtkAbstractTransform*)NULL);
   }
   else
   {
     //@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?
     return;
     AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldPlaneGeometry());
     if(worldAbstractGeometry.IsNotNull())
     {
       // set up vtkPlane according to worldGeometry
       point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
       FillVector3D(normal, 0, 0, 1);
       m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
     }
     else
       return;
   }
 
   double vp[ 3 ], vnormal[ 3 ];
 
   vnl2vtk(point.GetVnlVector(), vp);
   vnl2vtk(normal.GetVnlVector(), vnormal);
 
   //normally, we would need to transform the surface and cut the transformed surface with the cutter.
   //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
   //@todo It probably does not work for scaling operations yet:scaling operations have to be
   //dealed with after the cut is performed by scaling the contour.
   inversetransform->TransformPoint( vp, vp );
   inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );
 
   m_Plane->SetOrigin( vp );
   m_Plane->SetNormal( vnormal );
 
   // set data into cutter
   m_Slicer->SetInputData( m_VtkPointSet );
   //    m_Cutter->GenerateCutScalarsOff();
   //    m_Cutter->SetSortByToSortByCell();
 
   // calculate the cut
   m_Slicer->Update();
 
   // fetch geometry
   mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
   assert( displayGeometry );
   //  float toGL=displayGeometry->GetSizeInDisplayUnits()[1];
 
   //apply color and opacity read from the PropertyList
   ApplyColorAndOpacityProperties( renderer );
 
   // traverse the cut contour
   vtkPolyData * contour = m_Slicer->GetOutput();
 
   vtkPoints *vpoints = contour->GetPoints();
   vtkCellArray *vlines = contour->GetLines();
   vtkCellArray *vpolys = contour->GetPolys();
   vtkPointData *vpointdata = contour->GetPointData();
   vtkDataArray* vscalars = vpointdata->GetScalars();
 
   vtkCellData *vcelldata = contour->GetCellData();
   vtkDataArray* vcellscalars = vcelldata->GetScalars();
 
   const int numberOfLines = contour->GetNumberOfLines();
   const int numberOfPolys = contour->GetNumberOfPolys();
 
   const bool useCellData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT ||
       m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA;
   const bool usePointData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA;
 
   Point3D p;
   Point2D p2d;
 
   vlines->InitTraversal();
   vpolys->InitTraversal();
 
   mitk::Color outlineColor = m_Color->GetColor();
 
   glLineWidth((float)m_LineWidth->GetValue());
 
   for (int i = 0;i < numberOfLines;++i )
   {
     vtkIdType *cell(0);
     vtkIdType cellSize(0);
 
     vlines->GetNextCell( cellSize, cell );
 
     float rgba[4] = {outlineColor[0], outlineColor[1], outlineColor[2], 1.0f};
     if (m_ScalarVisibility->GetValue() && vcellscalars)
     {
       if ( useCellData )
       {  // color each cell according to cell data
         double scalar = vcellscalars->GetComponent( i, 0 );
         double rgb[3] = { 1.0f, 1.0f, 1.0f };
         m_ScalarsToColors->GetColor(scalar, rgb);
         rgba[0] = (float)rgb[0];
         rgba[1] = (float)rgb[1];
         rgba[2] = (float)rgb[2];
         rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
       }
       else if ( usePointData )
       {
         double scalar = vscalars->GetComponent( i, 0 );
         double rgb[3] = { 1.0f, 1.0f, 1.0f };
         m_ScalarsToColors->GetColor(scalar, rgb);
         rgba[0] = (float)rgb[0];
         rgba[1] = (float)rgb[1];
         rgba[2] = (float)rgb[2];
         rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
       }
     }
 
     glColor4fv( rgba );
 
     glBegin ( GL_LINE_LOOP );
     for ( int j = 0;j < cellSize;++j )
     {
       vpoints->GetPoint( cell[ j ], vp );
       //take transformation via vtktransform into account
       vtktransform->TransformPoint( vp, vp );
 
       vtk2itk( vp, p );
 
       //convert 3D point (in mm) to 2D point on slice (also in mm)
       worldGeometry->Map( p, p2d );
 
       //convert point (until now mm and in worldcoordinates) to display coordinates (units )
       displayGeometry->WorldToDisplay( p2d, p2d );
 
       //convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
       //p2d[1]=toGL-p2d[1];
 
       //add the current vertex to the line
       glVertex2f( p2d[0], p2d[1] );
     }
     glEnd ();
 
   }
 
   bool polyOutline = m_Outline->GetValue();
   bool scalarVisibility = m_ScalarVisibility->GetValue();
 
   // cache the transformed points
   // a fixed size array is way faster than 'new'
   // slices through 3d cells usually do not generated
   // polygons with more than 6 vertices
   const int maxPolySize = 10;
   Point2D* cachedPoints = new Point2D[maxPolySize*numberOfPolys];
 
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   // only draw polygons if there are cell scalars
   // or the outline property is set to true
   if (scalarVisibility && vcellscalars)
   {
     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
     for (int i = 0;i < numberOfPolys;++i )
     {
       vtkIdType *cell(0);
       vtkIdType cellSize(0);
 
       vpolys->GetNextCell( cellSize, cell );
 
       float rgba[4] = {1.0f, 1.0f, 1.0f, 0};
       if (scalarVisibility && vcellscalars)
       {
         if ( useCellData )
         {  // color each cell according to cell data
           double scalar = vcellscalars->GetComponent( i+numberOfLines, 0 );
           double rgb[3] = { 1.0f, 1.0f, 1.0f };
           m_ScalarsToColors->GetColor(scalar, rgb);
           rgba[0] = (float)rgb[0];
           rgba[1] = (float)rgb[1];
           rgba[2] = (float)rgb[2];
           rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
         }
         else if ( usePointData )
         {
           double scalar = vscalars->GetComponent( i, 0 );
           double rgb[3] = { 1.0f, 1.0f, 1.0f };
           m_ScalarsToColors->GetColor(scalar, rgb);
           rgba[0] = (float)rgb[0];
           rgba[1] = (float)rgb[1];
           rgba[2] = (float)rgb[2];
           rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
         }
       }
       glColor4fv( rgba );
 
       glBegin( GL_POLYGON );
       for (int j = 0; j < cellSize; ++j)
       {
         vpoints->GetPoint( cell[ j ], vp );
         //take transformation via vtktransform into account
         vtktransform->TransformPoint( vp, vp );
 
         vtk2itk( vp, p );
 
         //convert 3D point (in mm) to 2D point on slice (also in mm)
         worldGeometry->Map( p, p2d );
 
         //convert point (until now mm and in worldcoordinates) to display coordinates (units )
         displayGeometry->WorldToDisplay( p2d, p2d );
 
         //convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
         //p2d[1]=toGL-p2d[1];
 
         cachedPoints[i*10+j][0] = p2d[0];
         cachedPoints[i*10+j][1] = p2d[1];
 
         //add the current vertex to the line
         glVertex2f( p2d[0], p2d[1] );
       }
       glEnd();
     }
 
     if (polyOutline)
     {
       vpolys->InitTraversal();
 
       glColor4f(outlineColor[0], outlineColor[1], outlineColor[2], 1.0f);
       glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
       for (int i = 0;i < numberOfPolys;++i)
       {
         vtkIdType *cell(0);
         vtkIdType cellSize(0);
 
         vpolys->GetNextCell( cellSize, cell );
 
         glBegin( GL_POLYGON );
         //glPolygonOffset(1.0, 1.0);
         for (int j = 0; j < cellSize; ++j)
         {
           //add the current vertex to the line
           glVertex2f( cachedPoints[i*10+j][0], cachedPoints[i*10+j][1] );
         }
         glEnd();
       }
     }
   }
   glDisable(GL_BLEND);
   delete cachedPoints;
 }
 
 
 vtkAbstractMapper3D*
 mitk::UnstructuredGridMapper2D
 ::GetVtkAbstractMapper3D(mitk::BaseRenderer *  renderer)
 {
   //MITK_INFO << "GETVTKABSTRACTMAPPER3D\n";
   mitk::DataNode::ConstPointer node = this->GetDataNode();
   if ( node.IsNull() )
     return 0;
 
   mitk::VtkMapper::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper* > ( node->GetMapper( 2 ) );
   if ( mitkMapper.IsNull() )
   {
     return 0;
   }
 
   mitkMapper->Update(renderer);
 
   vtkAssembly* assembly = dynamic_cast<vtkAssembly*>(mitkMapper->GetVtkProp(renderer));
   if (assembly)
   {
     vtkProp3DCollection* collection = assembly->GetParts();
     collection->InitTraversal();
     vtkProp3D* prop3d = 0;
     do
     {
       prop3d = collection->GetNextProp3D();
       vtkActor* actor = dynamic_cast<vtkActor*>( prop3d );
       if (actor)
       {
         return dynamic_cast<vtkAbstractMapper3D*>( actor->GetMapper() );
       }
 
       vtkVolume* volume = dynamic_cast<vtkVolume*>( prop3d );
       if (volume)
       {
         return dynamic_cast<vtkAbstractMapper3D*>( volume->GetMapper() );
       }
     } while (prop3d != collection->GetLastProp3D());
   }
   else
   {
     vtkActor* actor = dynamic_cast<vtkActor*>( mitkMapper->GetVtkProp(renderer) );
     if (actor)
     {
       return dynamic_cast<vtkAbstractMapper3D*>( actor->GetMapper() );
     }
 
     vtkVolume* volume = dynamic_cast<vtkVolume*>( mitkMapper->GetVtkProp(renderer) );
     if (volume)
     {
       return dynamic_cast<vtkAbstractMapper3D*>( volume->GetMapper() );
     }
   }
   return 0;
 }
 
 
 
 vtkPointSet*
 mitk::UnstructuredGridMapper2D
-::GetVtkPointSet(mitk::BaseRenderer* renderer)
+::GetVtkPointSet(mitk::BaseRenderer* renderer, int time)
 {
   //MITK_INFO << "GETVTKPOINTSET\n";
   vtkAbstractMapper3D * abstractMapper = GetVtkAbstractMapper3D(renderer);
   if ( abstractMapper == 0 )
   {
     // try to get data from the node
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     if ( node.IsNull() )
       return 0;
     mitk::BaseData::Pointer data = node->GetData();
     mitk::UnstructuredGrid::Pointer grid = dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer());
     if (!grid.IsNull())
-      return static_cast<vtkPointSet*>(grid->GetVtkUnstructuredGrid());
+      return static_cast<vtkPointSet*>(grid->GetVtkUnstructuredGrid(time));
 
     return 0;
   }
   else
   {
     vtkMapper* mapper = dynamic_cast<vtkMapper*>(abstractMapper);
     if (mapper)
     {
       return dynamic_cast<vtkPointSet*>(mapper->GetInput());
     }
     vtkAbstractVolumeMapper* volMapper = dynamic_cast<vtkAbstractVolumeMapper*>(abstractMapper);
     if (volMapper)
     {
       return dynamic_cast<vtkPointSet*>(volMapper->GetDataSetInput());
     }
   }
 
   return 0;
 }
 
 
 
 vtkScalarsToColors* mitk::UnstructuredGridMapper2D::GetVtkLUT(mitk::BaseRenderer* renderer)
 {
   //MITK_INFO << "GETVTKLUT\n";
   vtkMapper * mapper = dynamic_cast<vtkMapper*>(GetVtkAbstractMapper3D(renderer));
   if (mapper)
     return mapper->GetLookupTable();
   else
   {
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     if ( node.IsNull() )
       return 0;
 
     mitk::VtkMapper::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper* > ( node->GetMapper( 2 ) );
     if ( mitkMapper.IsNull() )
     {
       //MITK_INFO << "mitkMapper is null\n";
       return 0;
     }
 
     mitkMapper->Update(renderer);
 
     vtkVolume* volume = dynamic_cast<vtkVolume*>( mitkMapper->GetVtkProp(renderer) );
     if (volume)
     {
       //MITK_INFO << "found volume prop\n";
       return static_cast<vtkScalarsToColors*>(volume->GetProperty()->GetRGBTransferFunction());
     }
 
     vtkAssembly* assembly = dynamic_cast<vtkAssembly*>(mitkMapper->GetVtkProp(renderer));
     if (assembly)
     {
       //MITK_INFO << "found assembly prop\n";
       mitk::TransferFunctionProperty::Pointer transferFuncProp;
       node->GetProperty(transferFuncProp, "TransferFunction", 0);
       if (transferFuncProp.IsNotNull())
       {
         MITK_INFO << "return colortransferfunction\n";
         return static_cast<vtkScalarsToColors*>(transferFuncProp->GetValue()->GetColorTransferFunction());
       }
     }
     return 0;
   }
 }
 
 
 bool mitk::UnstructuredGridMapper2D::IsConvertibleToVtkPointSet(mitk::BaseRenderer * renderer)
 {
-  return ( GetVtkPointSet(renderer) != 0 );
+  return ( GetVtkPointSet(renderer,this->GetTimestep()) != 0);
 }
 
 mitk::UnstructuredGridMapper2D::UnstructuredGridMapper2D()
 {
   m_Plane = vtkPlane::New();
   m_Slicer = vtkPointSetSlicer::New();
 
   m_Slicer->SetSlicePlane( m_Plane );
 
   m_ScalarsToColors = 0;
   m_ScalarsToOpacity = 0;
   m_VtkPointSet = 0;
 
   //m_LUT = vtkLookupTable::New();
   //m_LUT->SetTableRange( 0, 255 );
   //m_LUT->SetNumberOfColors( 255 );
   //m_LUT->SetRampToLinear ();
   //m_LUT->Build();
 }
 
 
 
 mitk::UnstructuredGridMapper2D::~UnstructuredGridMapper2D()
 {
   m_Slicer->Delete();
   m_Plane->Delete();
 
   if (m_ScalarsToOpacity != 0) m_ScalarsToOpacity->UnRegister(0);
   if (m_ScalarsToColors != 0) m_ScalarsToColors->UnRegister(0);
   if (m_VtkPointSet != 0) m_VtkPointSet->UnRegister(0);
 }