diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
index 2e7cf6d501..53b71678ca 100644
--- a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
@@ -1,249 +1,251 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY 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;
   m_GeometryVector.resize(1);
 }
 
 mitk::TimeStepType mitk::ProportionalTimeGeometry::CountTimeSteps () 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 * CountTimeSteps();
   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;
 }
 
 mitk::TimePointType  mitk::ProportionalTimeGeometry::GetMinimumTimePoint(TimeStepType step) const
 {
   TimePointType timePoint = m_FirstTimePoint + m_StepDuration * step;
   if (timePoint >std::numeric_limits<TimePointType>().max())
     timePoint = std::numeric_limits<TimePointType>().max();
   return timePoint;
 }
 
 mitk::TimePointType   mitk::ProportionalTimeGeometry::GetMaximumTimePoint(TimeStepType step) const
 {
   TimePointType timePoint = m_FirstTimePoint + m_StepDuration * (step + 1);
   if (timePoint >std::numeric_limits<TimePointType>().max())
     timePoint = std::numeric_limits<TimePointType>().max();
   return timePoint;
 }
 
 
 mitk::TimeBounds mitk::ProportionalTimeGeometry::GetTimeBounds(TimeStepType step) const
 {
   TimeBounds bounds;
   bounds[0] = this->GetMinimumTimePoint(step);
   bounds[1] = this->GetMaximumTimePoint(step);
   return bounds;
 }
 
 bool mitk::ProportionalTimeGeometry::IsValidTimePoint (TimePointType timePoint) const
 {
   return this->GetMinimumTimePoint() <= timePoint && timePoint < this->GetMaximumTimePoint();
 }
 
 bool mitk::ProportionalTimeGeometry::IsValidTimeStep (TimeStepType timeStep) const
 {
   return timeStep <  this->CountTimeSteps();
 }
 
 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());
 
   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->CountTimeSteps());
   for (TimeStepType i =0; i < CountTimeSteps(); ++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 = 0.0;
   m_StepDuration = 1.0;
+  if (timeSteps < 2)
+  {
+    m_FirstTimePoint = -std::numeric_limits<mitk::TimePointType>().max();
+    m_StepDuration = std::numeric_limits<mitk::TimePointType>().infinity();
+  }
+
   this->ReserveSpaceForGeometries(timeSteps);
   try{
   for (TimeStepType currentStep = 0; currentStep < timeSteps; ++currentStep)
   {
-    mitk::TimeBounds timeBounds;
-    timeBounds[0] = m_FirstTimePoint + currentStep * m_StepDuration;
-    timeBounds[1] = m_FirstTimePoint + (currentStep+1) * m_StepDuration;
-
     Geometry3D::Pointer clonedGeometry = geometry->Clone();
     this->SetTimeStepGeometry(clonedGeometry.GetPointer(), currentStep);
   }
   }
   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();
 
   this->Initialize(geometry.GetPointer(), timeSteps);
 }
 
 void mitk::ProportionalTimeGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " TimeSteps: " << this->CountTimeSteps() << std::endl;
   os << indent << " FirstTimePoint: " << this->GetFirstTimePoint() << std::endl;
   os << indent << " StepDuration: " << this->GetStepDuration() << " ms" << std::endl;
 
   os << std::endl;
   os << indent << " GetGeometryForTimeStep(0): ";
   if(GetGeometryForTimeStep(0).IsNull())
     os << "NULL" << std::endl;
   else
     GetGeometryForTimeStep(0)->Print(os, indent);
 }
\ No newline at end of file
diff --git a/Core/Code/Testing/mitkTextOverlay3DRendering2DTest.cpp b/Core/Code/Testing/mitkTextOverlay3DRendering2DTest.cpp
index d076f25f8c..a7908efb15 100644
--- a/Core/Code/Testing/mitkTextOverlay3DRendering2DTest.cpp
+++ b/Core/Code/Testing/mitkTextOverlay3DRendering2DTest.cpp
@@ -1,89 +1,89 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY 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 "mitkTestingMacros.h"
 #include "mitkRenderingTestHelper.h"
 #include <mitkOverlayManager.h>
 
 //VTK
 #include <vtkRegressionTestImage.h>
 #include "mitkTextOverlay3D.h"
 #include <mitkPointSet.h>
 
 
 int mitkTextOverlay3DRendering2DTest(int argc, char* argv[])
 {
   // load all arguments into a datastorage, take last argument as reference rendering
   // setup a renderwindow of fixed size X*Y
   // render the datastorage
   // compare rendering to reference image
   MITK_TEST_BEGIN("mitkTextOverlay3DRendering2DTest")
 
   mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
 
   mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow());
   mitk::OverlayManager::Pointer overlayManager = mitk::OverlayManager::New();
   renderer->SetOverlayManager(overlayManager);
 
   mitk::PointSet::Pointer pointset = mitk::PointSet::New();
 
   // This vector is used to define an offset for the annotations, in order to show them with a margin to the actual coordinate.
   mitk::Point3D offset;
   offset[0] = .5;
   offset[1] = .5;
   offset[2] = .5;
 
   //Just a loop to create some points
   for(int i=0 ; i < 5 ; i++){
       //To each point, a TextOverlay3D is created
       mitk::TextOverlay3D::Pointer textOverlay3D = mitk::TextOverlay3D::New();
       mitk::Point3D point;
       point[0] = i*2;
       point[1] = i*3;
       point[2] = -i*5;
       pointset->InsertPoint(i, point);
       textOverlay3D->SetText("A Point");
 
       // The Position is set to the point coordinate to create an annotation to the point in the PointSet.
       textOverlay3D->SetPosition3D(point);
 
       // move the annotation away from the actual point
       textOverlay3D->SetOffsetVector(offset);
 
       overlayManager->AddOverlay(textOverlay3D.GetPointer());
   }
 
   // also show the created pointset
   mitk::DataNode::Pointer datanode = mitk::DataNode::New();
   datanode->SetData(pointset);
   datanode->SetName("pointSet");
   renderingHelper.AddNodeToStorage(datanode);
   renderingHelper.Render();
 
   //use this to generate a reference screenshot or save the file:
-  bool generateReferenceScreenshot = false;
+  bool generateReferenceScreenshot = true;
   if(generateReferenceScreenshot)
   {
-    renderingHelper.SaveReferenceScreenShot("/home/christoph/Pictures/RenderingTestData/mitkTextOverlay3DRendering2DTest_ball.png");
+    renderingHelper.SaveReferenceScreenShot("d:/tmp/mitkTextOverlay3DRendering2DTest_ball.png");
   }
 
   //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
   MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
 
   MITK_TEST_END();
 }