diff --git a/Modules/Core/include/mitkArbitraryTimeGeometry.h b/Modules/Core/include/mitkArbitraryTimeGeometry.h
index 6c3a4c63e9..1b2657cbca 100644
--- a/Modules/Core/include/mitkArbitraryTimeGeometry.h
+++ b/Modules/Core/include/mitkArbitraryTimeGeometry.h
@@ -1,247 +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.
 
 ===================================================================*/
 
 #ifndef ArbitraryTimeGeometry_h
 #define ArbitraryTimeGeometry_h
 
 //MITK
 #include <mitkTimeGeometry.h>
 #include <mitkCommon.h>
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   /**
   * \brief Organizes geometries over arbitrary defined time steps
   *
   * For this TimeGeometry implementation it is assumed that
   * the durations of the time steps are arbitrary and may differ.
   * 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.
   * @remark The lower time bound of a succeeding time step may not be smaller
   * than the upper time bound of its predecessor. Thus the list of time points is
   * always sorted by its lower time bounds.
   * @remark For the conversion between time step and time point the following assumption
   * is used.:\n
   * time step -> time point: time point is the lower time bound of the geometry indicated by step.\n
   * time point -> time step: associated time step is last step which lower time bound is smaller or equal then the time
   * point.
   *
   * \addtogroup geometry
   */
   class MITKCORE_EXPORT ArbitraryTimeGeometry : public TimeGeometry
   {
   public:
     mitkClassMacro(ArbitraryTimeGeometry, TimeGeometry);
 
     ArbitraryTimeGeometry();
     typedef ArbitraryTimeGeometry self;
     itkFactorylessNewMacro(Self)
     itkCloneMacro(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.
       */
       TimeStepType CountTimeSteps() const override;
     /**
     * \brief Returns the first time point for which the time geometry instance is valid.
     *
     * Returns the first valid time point for this geometry. It is the lower time bound of
     * the first step. The time point is given in ms.
     */
     TimePointType GetMinimumTimePoint() const override;
     /**
     * \brief Returns the last time point for which the time geometry instance is valid
     *
     * Gives the last time point for which a valid geometry is saved in
     * this time geometry. It is the upper time bound of the last step.
     * The time point is given in ms.
     */
     TimePointType GetMaximumTimePoint() const override;
 
     /**
     * \brief Returns the first time point for which the time geometry instance is valid.
     *
     * Returns the first valid time point for the given TimeStep. The time point
     * is given in ms.
     */
     TimePointType GetMinimumTimePoint(TimeStepType step) const override;
     /**
     * \brief Returns the last time point for which the time geometry instance is valid
     *
     * Gives the last time point for the Geometry specified by the given TimeStep. The time point is given in ms.
     */
     TimePointType GetMaximumTimePoint(TimeStepType step) const override;
 
     /**
     * \brief Get the time bounds (in ms)
     * it returns GetMinimumTimePoint() and GetMaximumTimePoint() results as bounds.
     */
     TimeBounds GetTimeBounds() const override;
 
     /**
     * \brief Get the time bounds for the given TimeStep (in ms)
     */
     TimeBounds GetTimeBounds(TimeStepType step) const override;
 
     /**
     * \brief Tests if a given time point is covered by this time geometry instance
     *
     * Returns true if a geometry can be returned for the given time
     * point (so it is within GetTimeBounds() and fails if not.
     * The time point must be given in ms.
     */
     bool IsValidTimePoint(TimePointType timePoint) const override;
     /**
     * \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.
     */
     bool IsValidTimeStep(TimeStepType timeStep) const override;
     /**
     * \brief Converts a time step to a time point
     *
     * Converts a time step to a time point by using the time steps lower
     * time bound.
     * 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.
     */
     TimePointType TimeStepToTimePoint(TimeStepType timeStep) const override;
     /**
   * \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.
   * The associated time step is the last step which lower time bound
   * is smaller or equal then the time point.
   * If a negative invalid time point is given always time step 0 is
-  * returned. If an positive invalid time step is given an invalid
-  * time step will be returned.
+  * returned. If a positive invalid time point is given the last time
+  * step will be returned. This is also true for time points that are
+  * exactly on the upper time bound.
   */
     TimeStepType TimePointToTimeStep(TimePointType timePoint) const override;
     /**
     * \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.
     */
     BaseGeometry::Pointer GetGeometryCloneForTimeStep(TimeStepType timeStep) const override;
 
     /**
     * \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.
     */
     BaseGeometry::Pointer GetGeometryForTimePoint(TimePointType timePoint) const override;
     /**
     * \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.
     */
     BaseGeometry::Pointer GetGeometryForTimeStep(TimeStepType timeStep) const override;
 
     /**
     * \brief Tests if all necessary informations are set and the object is valid
     */
     bool IsValid() const override;
 
     /**
     * \brief Initializes a new object with one time steps which contains an empty geometry.
     */
     void Initialize() override;
 
     /**
     * \brief Expands the time geometry to the given number of time steps.
     *
     * Initializes the new time steps with empty geometries. This default geometries will behave like
     * ProportionalTimeGeometry.
     * Shrinking is not supported. The new steps will have the same duration like the last step before extension.
     */
     void Expand(TimeStepType size) override;
 
     /**
     * \brief Replaces the geometry instances with clones of the passed geometry.
     *
     * Replaces the geometries of all time steps with clones of the passed
     * geometry. Replacement strategy depends on the implementation of TimeGeometry
     * sub class.
     * @remark The time points itself stays untouched. Use this method if you want
     * to change the spatial properties of a TimeGeometry and preserve the time
     * "grid".
     */
     void ReplaceTimeStepGeometries(const BaseGeometry *geometry) override;
 
     /**
     * \brief Sets the geometry for the given time step
     *
     * If passed time step is not valid. Nothing will be changed.
     * @pre geometry must point to a valid instance.
     */
     void SetTimeStepGeometry(BaseGeometry *geometry, TimeStepType timeStep) override;
 
     /**
     * \brief Makes a deep copy of the current object
     */
     itk::LightObject::Pointer InternalClone() const override;
 
     void ClearAllGeometries();
 
     /** Append the passed geometry to the time geometry.
      * @pre The passed geometry pointer must be valid.
      * @pre The minimumTimePoint must not be smaller than the maximum time point of the currently last time step.
      * Therefore time steps must not be overlapping in time.
      * @pre minimumTimePoint must not be larger then maximumTimePoint.*/
     void AppendNewTimeStep(BaseGeometry *geometry, TimePointType minimumTimePoint, TimePointType maximumTimePoint);
 
     /** Same than AppendNewTimeStep. But clones geometry before adding it.*/
     void AppendNewTimeStepClone(const BaseGeometry* geometry,
                               TimePointType minimumTimePoint,
                               TimePointType maximumTimePoint );
 
     void ReserveSpaceForGeometries( TimeStepType numberOfGeometries );
 
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
   protected:
     ~ArbitraryTimeGeometry() override;
 
     std::vector<BaseGeometry::Pointer> m_GeometryVector;
     std::vector<TimePointType> m_MinimumTimePoints;
     std::vector<TimePointType> m_MaximumTimePoints;
 
   }; // end class ArbitraryTimeGeometry
 
 } // end namespace MITK
 #endif // ArbitraryTimeGeometry_h
diff --git a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
index c2322cb5c2..0f8278e2c6 100644
--- a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
@@ -1,297 +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.
 
 ===================================================================*/
 #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();
   }
   return result;
 }
 
 mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMinimumTimePoint( TimeStepType step ) const
 {
   TimePointType result = GetMinimumTimePoint();
   if (step > 0 && step <= m_MaximumTimePoints.size())
   {
     result = m_MaximumTimePoints[step - 1];
   }
   return result;
 };
 
 mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMaximumTimePoint( TimeStepType step ) const
 {
   TimePointType result = 0;
   if (step < m_MaximumTimePoints.size())
   {
     result = m_MaximumTimePoints[step];
   }
   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();
 }
 
 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() )
+  if (timePoint >= GetMinimumTimePoint())
   {
-    for ( auto pos = m_MaximumTimePoints.cbegin(); pos != m_MaximumTimePoints.cend(); ++pos )
+    for (auto pos = m_MaximumTimePoints.cbegin(); pos != m_MaximumTimePoints.cend(); ++pos)
     {
       if (timePoint < *pos)
       {
-        result = pos - m_MaximumTimePoints.begin();
         break;
       }
+
+      ++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;
   }
 }