diff --git a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
index c0e0037e9e..f287df5d52 100644
--- a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
@@ -1,350 +1,344 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include <limits>
 #include <mitkArbitraryTimeGeometry.h>
 
 #include <algorithm>
 
 #include <mitkGeometry3D.h>
 
 mitk::ArbitraryTimeGeometry::ArbitraryTimeGeometry() = default;
 
 mitk::ArbitraryTimeGeometry::~ArbitraryTimeGeometry() = default;
 
 void mitk::ArbitraryTimeGeometry::Initialize()
 {
   this->ClearAllGeometries();
   Geometry3D::Pointer geo = Geometry3D::New();
   geo->Initialize();
 
   this->AppendNewTimeStep(geo, 0, 1);
 
   Update();
 }
 
 mitk::TimeStepType mitk::ArbitraryTimeGeometry::CountTimeSteps() const
 {
   return static_cast<TimeStepType>(m_GeometryVector.size());
 }
 
 mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMinimumTimePoint() const
 {
   return m_MinimumTimePoints.empty() ? 0.0 : m_MinimumTimePoints.front();
 }
 
 mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMaximumTimePoint() const
 {
   TimePointType result = 0;
   if ( !m_MaximumTimePoints.empty() )
   {
     result = m_MaximumTimePoints.back();
   }
 
   ///////////////////////////////////////
   // Workarround T27883. See https://phabricator.mitk.org/T27883#219473 for more details.
   // This workarround should be removed as soon as T28262 is solved!
   if (this->HasCollapsedFinalTimeStep())
   {
-    result = m_MinimumTimePoints.back() + 1.;
+    result = m_MinimumTimePoints.back() + 1;
   }
   // End of workarround for T27883
   //////////////////////////////////////
 
   return result;
 }
 
 mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMinimumTimePoint( TimeStepType step ) const
 {
-  TimePointType result = 0;
-  if (step < m_MinimumTimePoints.size())
-  {
-    result = m_MinimumTimePoints[step];
-  }
-
-  return result;
+  return step < m_MinimumTimePoints.size() ? m_MinimumTimePoints[step] : 0.0f;
 };
 
 mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMaximumTimePoint( TimeStepType step ) const
 {
   TimePointType result = 0;
   if (step < m_MaximumTimePoints.size())
   {
     result = m_MaximumTimePoints[step];
   }
 
   ///////////////////////////////////////
   // Workarround T27883. See https://phabricator.mitk.org/T27883#219473 for more details.
   // This workarround should be removed as soon as T28262 is solved!
   if (step + 1 == m_MaximumTimePoints.size() && this->HasCollapsedFinalTimeStep())
   {
-    result = m_MinimumTimePoints[step] + 1.;
+    result = m_MinimumTimePoints[step] + 1;
   }
   // End of workarround for T27883
   //////////////////////////////////////
 
   return result;
 };
 
 mitk::TimeBounds mitk::ArbitraryTimeGeometry::GetTimeBounds() const
 {
   TimeBounds bounds;
   bounds[0] = this->GetMinimumTimePoint();
   bounds[1] = this->GetMaximumTimePoint();
   return bounds;
 }
 
 mitk::TimeBounds mitk::ArbitraryTimeGeometry::GetTimeBounds(TimeStepType step) const
 {
   TimeBounds bounds;
   bounds[0] = this->GetMinimumTimePoint( step );
   bounds[1] = this->GetMaximumTimePoint( step );
   return bounds;
 }
 
 bool mitk::ArbitraryTimeGeometry::IsValidTimePoint(TimePointType timePoint) const
 {
   return this->GetMinimumTimePoint() <= timePoint &&
     (timePoint < this->GetMaximumTimePoint() || (this->HasCollapsedFinalTimeStep() && timePoint <= this->GetMaximumTimePoint()));
 }
 
 bool mitk::ArbitraryTimeGeometry::IsValidTimeStep(TimeStepType timeStep) const
 {
   return timeStep < this->CountTimeSteps();
 }
 
 mitk::TimePointType mitk::ArbitraryTimeGeometry::TimeStepToTimePoint( TimeStepType timeStep ) const
 {
   TimePointType result = 0.0;
 
   if (timeStep < m_MinimumTimePoints.size() )
   {
     result = m_MinimumTimePoints[timeStep];
   }
 
   return result;
 }
 
 mitk::TimeStepType mitk::ArbitraryTimeGeometry::TimePointToTimeStep(TimePointType timePoint) const
 {
   mitk::TimeStepType result = 0;
 
   if (timePoint >= GetMinimumTimePoint())
   {
     for (auto pos = m_MaximumTimePoints.cbegin(); pos != m_MaximumTimePoints.cend(); ++pos)
     {
       ///////////////////////////////////////
       // Workarround T27883. See https://phabricator.mitk.org/T27883#219473 for more details.
       // The part ("+1.") inline marked as workarround should be removed as soon as T28262 is solved!
       if (timePoint < *pos
           || (pos == std::prev(m_MaximumTimePoints.cend())
-              && timePoint <= *pos +1.//<- +1. is the workarround
+              && timePoint <= *pos +1//<- +1 is the workarround
               && this->HasCollapsedFinalTimeStep()))
       {
         break;
       }
       // End of workarround for T27883
       //////////////////////////////////////
 
       ++result;
     }
   }
 
   return result;
 }
 
 mitk::BaseGeometry::Pointer mitk::ArbitraryTimeGeometry::GetGeometryForTimeStep(TimeStepType timeStep) const
 {
   if ( IsValidTimeStep( timeStep ) )
   {
     return m_GeometryVector[timeStep];
   }
   else
   {
     return nullptr;
   }
 }
 
 mitk::BaseGeometry::Pointer
   mitk::ArbitraryTimeGeometry::GetGeometryForTimePoint( TimePointType timePoint ) const
 {
   if ( this->IsValidTimePoint( timePoint ) )
   {
     const TimeStepType timeStep = this->TimePointToTimeStep( timePoint );
     return this->GetGeometryForTimeStep( timeStep );
   }
   else
   {
     return nullptr;
   }
 }
 
 mitk::BaseGeometry::Pointer
   mitk::ArbitraryTimeGeometry::GetGeometryCloneForTimeStep( TimeStepType timeStep ) const
 {
   if ( timeStep >= m_GeometryVector.size() )
     return nullptr;
   return m_GeometryVector[timeStep]->Clone();
 }
 
 bool mitk::ArbitraryTimeGeometry::IsValid() const
 {
   bool isValid = true;
   isValid &= m_GeometryVector.size() > 0;
   return isValid;
 }
 
 void mitk::ArbitraryTimeGeometry::ClearAllGeometries()
 {
   m_GeometryVector.clear();
   m_MinimumTimePoints.clear();
   m_MaximumTimePoints.clear();
 }
 
 void mitk::ArbitraryTimeGeometry::ReserveSpaceForGeometries( TimeStepType numberOfGeometries )
 {
   m_GeometryVector.reserve( numberOfGeometries );
   m_MinimumTimePoints.reserve( numberOfGeometries );
   m_MaximumTimePoints.reserve( numberOfGeometries );
 }
 
 void mitk::ArbitraryTimeGeometry::Expand( mitk::TimeStepType size )
 {
   m_GeometryVector.reserve( size );
 
   const mitk::TimeStepType lastIndex = this->CountTimeSteps() - 1;
   const TimePointType minTP    = this->GetMinimumTimePoint( lastIndex );
   TimePointType maxTP          = this->GetMaximumTimePoint( lastIndex );
   const TimePointType duration = maxTP - minTP;
 
   while (m_GeometryVector.size() < size)
   {
     m_GeometryVector.push_back( Geometry3D::New().GetPointer() );
     m_MinimumTimePoints.push_back( maxTP );
     maxTP += duration;
     m_MaximumTimePoints.push_back( maxTP );
   }
 }
 
 void mitk::ArbitraryTimeGeometry::ReplaceTimeStepGeometries(const BaseGeometry *geometry)
 {
   for ( auto pos = m_GeometryVector.begin(); pos != m_GeometryVector.end(); ++pos )
   {
     *pos = geometry->Clone();
   }
 }
 
 void mitk::ArbitraryTimeGeometry::SetTimeStepGeometry(BaseGeometry *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::ArbitraryTimeGeometry::InternalClone() const
 {
   itk::LightObject::Pointer parent = Superclass::InternalClone();
   ArbitraryTimeGeometry::Pointer newTimeGeometry = dynamic_cast<ArbitraryTimeGeometry *>(parent.GetPointer());
   newTimeGeometry->m_MinimumTimePoints = this->m_MinimumTimePoints;
   newTimeGeometry->m_MaximumTimePoints = this->m_MaximumTimePoints;
   newTimeGeometry->m_GeometryVector.clear();
   for (TimeStepType i = 0; i < CountTimeSteps(); ++i)
   {
     newTimeGeometry->m_GeometryVector.push_back( this->m_GeometryVector[i]->Clone() );
   }
   return parent;
 }
 
 void mitk::ArbitraryTimeGeometry::AppendNewTimeStep(BaseGeometry *geometry,
   TimePointType minimumTimePoint,
   TimePointType maximumTimePoint)
 {
   if ( !geometry )
   {
     mitkThrow() << "Cannot append geometry to time geometry. Invalid geometry passed (nullptr pointer).";
   }
 
   if (maximumTimePoint < minimumTimePoint)
   {
     mitkThrow() << "Cannot append geometry to time geometry. Time bound conflict. Maxmimum time point ("<<maximumTimePoint<<") is smaller than minimum time point ("<<minimumTimePoint<<").";
   }
 
   if ( !m_GeometryVector.empty() )
   {
     if ( m_MaximumTimePoints.back() > minimumTimePoint )
     {
       mitkThrow() << "Cannot append geometry to time geometry. Time bound conflict new time point and currently last time point overlapp.";
     }
   }
 
   m_GeometryVector.push_back( geometry );
   m_MinimumTimePoints.push_back( minimumTimePoint );
   m_MaximumTimePoints.push_back( maximumTimePoint );
 }
 
 void mitk::ArbitraryTimeGeometry::AppendNewTimeStepClone(const BaseGeometry *geometry,
                                                       TimePointType minimumTimePoint,
                                                       TimePointType maximumTimePoint)
 {
   BaseGeometry::Pointer clone = geometry->Clone();
 
   this->AppendNewTimeStep(clone, minimumTimePoint, maximumTimePoint);
 };
 
 void mitk::ArbitraryTimeGeometry::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 
   os << indent << " MinimumTimePoint: " << this->GetMinimumTimePoint() << " ms" << std::endl;
   os << indent << " MaximumTimePoint: " << this->GetMaximumTimePoint() << " ms" << std::endl;
 
   os << std::endl;
   os << indent << " min TimeBounds: " << std::endl;
   for (TimeStepType i = 0; i < m_MinimumTimePoints.size(); ++i)
   {
     os << indent.GetNextIndent() << "Step " << i << ": " << m_MinimumTimePoints[i] << " ms" << std::endl;
   }
   os << std::endl;
   os << indent << " max TimeBounds: " << std::endl;
   for (TimeStepType i = 0; i < m_MaximumTimePoints.size(); ++i)
   {
     os << indent.GetNextIndent() << "Step " << i << ": " << m_MaximumTimePoints[i] << " ms" << std::endl;
   }
   ///////////////////////////////////////
   // Workarround T27883. See https://phabricator.mitk.org/T27883#219473 for more details.
   // This workarround should be removed as soon as T28262 is solved!
   if (this->HasCollapsedFinalTimeStep())
   {
-    os << "Caution: This time geometry has a collapsed finale time step." << std::endl;
-    os << "         Most likely reason is that no duration could be deduced from the original data" << std::endl;
-    os << "         (e.g.DICOM dynamic series stored as single frame images)." << std::endl;
-    os << "         Currently we expand it by 1 ms (see T27883 for more details)." << std::endl;
+    os << indent << "Caution: This time geometry has a collapsed finale time step." << std::endl;
+    os << indent << "         Most likely reason is that no duration could be deduced from the original data" << std::endl;
+    os << indent << "         (e.g. DICOM dynamic series stored as single frame images)." << std::endl;
+    os << indent << "         Currently we expand it by 1 ms (see T27883 for more details)." << std::endl;
   }
   // End of workarround for T27883
   //////////////////////////////////////
 }
 
 bool mitk::ArbitraryTimeGeometry::HasCollapsedFinalTimeStep() const
 {
   bool result = false;
 
   if (!m_MaximumTimePoints.empty() && !m_MinimumTimePoints.empty())
   {
     result = m_MinimumTimePoints.back() == m_MaximumTimePoints.back();
   }
 
   return result;
 }