diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h
index 422dafb41b..47c2993697 100644
--- a/Modules/Core/include/mitkBaseRenderer.h
+++ b/Modules/Core/include/mitkBaseRenderer.h
@@ -1,556 +1,556 @@
 /*===================================================================
 
 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 "mitkCameraRotationController.h"
 #include "mitkDataStorage.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneGeometryData.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkTimeGeometry.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 KeyEvent;
 
   //##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 MITKCORE_EXPORT BaseRenderer : public itk::Object
   {
   public:
     /** \brief This rendering mode enumeration is specified at various constructors
     *  of the Renderer and RenderWindow classes, which autoconfigures the
     *  respective VTK objects. This has to be done at construction time because later
     *  configuring turns out to be not working on most platforms.
     */
     struct RenderingMode
     {
       enum Type
       {
         Standard = 0
       };
     };
 
     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. */
     mitkClassMacroItkParent(BaseRenderer, itk::Object);
 
     BaseRenderer(const char *name = nullptr,
                  vtkRenderWindow *renWin = nullptr,
                  mitk::RenderingManager *rm = nullptr,
                  RenderingMode::Type mode = RenderingMode::Standard);
 
     //##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 BaseGeometry more or less information can be extracted:
     //## \li if it is a PlaneGeometry (which is a sub-class of BaseGeometry), m_CurrentWorldPlaneGeometry is
     //## also set to point to it. m_WorldTimeGeometry is set to nullptr.
     //## \li if it is a TimeGeometry, m_WorldTimeGeometry is also set to point to it.
     //## If m_WorldTimeGeometry contains instances of SlicedGeometry3D, m_CurrentWorldPlaneGeometry 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 BaseGeometry is set as the
     //## m_CurrentWorldPlaneGeometry.
     //## \li otherwise a PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## is set as the m_CurrentWorldPlaneGeometry. m_WorldTimeGeometry is set to nullptr.
     //## @todo add calculation of PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## when the passed BaseGeometry is not sliced.
     //## \sa m_WorldGeometry
     //## \sa m_WorldTimeGeometry
     //## \sa m_CurrentWorldPlaneGeometry
-    virtual void SetWorldGeometry3D(BaseGeometry *geometry);
-    virtual void SetWorldTimeGeometry(mitk::TimeGeometry *geometry);
+    virtual void SetWorldGeometry3D(const BaseGeometry *geometry);
+    virtual void SetWorldTimeGeometry(const mitk::TimeGeometry *geometry);
 
     /**
     * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see
     * http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(void SetWorldGeometry3D(TimeSlicedGeometry *geometry));
 
-    itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry) itkGetObjectMacro(WorldTimeGeometry, TimeGeometry)
+    itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry)
 
       //##Documentation
       //## @brief Get the current 3D-worldgeometry (m_CurrentWorldGeometry) used for 3D-rendering
       itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry)
 
       //##Documentation
       //## @brief Get the current 2D-worldgeometry (m_CurrentWorldPlaneGeometry) used for 2D-rendering
       itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometry
       */
       DEPRECATED(const PlaneGeometry *GetCurrentWorldGeometry2D())
     {
       return GetCurrentWorldPlaneGeometry();
     };
 
     //##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 m_Slice which defines together with m_TimeStep the 2D geometry
     //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
     //##
     //## \sa m_Slice
     virtual void SetSlice(unsigned int slice);
 
     itkGetConstMacro(Slice, unsigned int)
 
       //##Documentation
       //## @brief Set/Get m_TimeStep which defines together with m_Slice the 2D geometry
       //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
       //##
       //## \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 DataNode pointing to a data object containing the current 2D-worldgeometry
     // m_CurrentWorldPlaneGeometry (for 2D rendering)
     itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryNode
       */
       DEPRECATED(DataNode *GetCurrentWorldGeometry2DNode())
     {
       return GetCurrentWorldPlaneGeometryNode();
     };
 
     //##Documentation
     //## @brief Sets timestamp of CurrentWorldPlaneGeometry and forces so reslicing in that renderwindow
     void SendUpdateSlice();
 
     //##Documentation
     //## @brief Get timestamp of last call of SetCurrentWorldPlaneGeometry
     unsigned long GetCurrentWorldPlaneGeometryUpdateTime() { return m_CurrentWorldPlaneGeometryUpdateTime; }
     /**
     * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryUpdateTime
     */
     DEPRECATED(unsigned long GetCurrentWorldGeometry2DUpdateTime())
     {
       return GetCurrentWorldPlaneGeometryUpdateTime();
     };
     //##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
     virtual void PickWorldPoint(const Point2D &diplayPosition, Point3D &worldPosition) const = 0;
 
     /** \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 nullptr;
     }
 
     //##Documentation
     //## @brief Get the MapperSlotId to use.
     itkGetMacro(MapperID, MapperSlotId) itkGetConstMacro(MapperID, MapperSlotId)
 
       //##Documentation
       //## @brief Set the MapperSlotId to use.
       itkSetMacro(MapperID, MapperSlotId)
 
         virtual int *GetSize() const;
     virtual int *GetViewportSize() const;
 
     void SetSliceNavigationController(SliceNavigationController *SlicenavigationController);
     itkGetObjectMacro(CameraController, CameraController)
       itkGetObjectMacro(SliceNavigationController, SliceNavigationController)
         itkGetObjectMacro(CameraRotationController, CameraRotationController)
 
           itkGetMacro(EmptyWorldGeometry, bool)
 
       //##Documentation
       //## @brief Tells if the displayed region is shifted and rescaled if the render window is resized.
       itkGetMacro(KeepDisplayedRegion, bool)
       //##Documentation
       //## @brief Tells if the displayed region should be shifted and rescaled if the render window is resized.
       itkSetMacro(KeepDisplayedRegion, bool)
 
       //##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 GetSize()[0]; }
     //##Documentation
     //## @brief get the y_size of the RendererWindow
     //## @note
     int GetSizeY() const { return GetSize()[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;
 
     //##Documentation
     //## @brief This method converts a display point to the 3D world index
     //## using the geometry of the renderWindow.
     void DisplayToWorld(const Point2D &displayPoint, Point3D &worldIndex) const;
 
     //##Documentation
     //## @brief This method converts a display point to the 2D world index, mapped onto the display plane
     //## using the geometry of the renderWindow.
     void DisplayToPlane(const Point2D &displayPoint, Point2D &planePointInMM) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the display point
     //## using the geometry of the renderWindow.
     void WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the point on the viewport
     //## using the geometry of the renderWindow.
     void WorldToView(const Point3D &worldIndex, Point2D &viewPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the display point
     //## using the geometry of the renderWindow.
     void PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the point on the viewport
     //## using the geometry of the renderWindow.
     void PlaneToView(const Point2D &planePointInMM, Point2D &viewPoint) const;
 
 
     double GetScaleFactorMMPerDisplayUnit() const;
 
     Point2D GetDisplaySizeInMM() const;
     Point2D GetViewportSizeInMM() const;
 
     Point2D GetOriginInMM() const;
 
     itkGetConstMacro(ConstrainZoomingAndPanning, bool) virtual void SetConstrainZoomingAndPanning(bool constrain);
 
     /**
     * \brief Provides (1) world coordinates for a given mouse position and (2)
     * translates mousePosition to Display coordinates
     * \deprecated Map2DRendererPositionTo3DWorldPosition is deprecated. Please use DisplayToWorld instead.
     */
     DEPRECATED(virtual Point3D Map2DRendererPositionTo3DWorldPosition(const Point2D &mousePosition) const);
 
   protected:
     ~BaseRenderer() override;
 
     //##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.
     itk::SmartPointer<CameraController> m_CameraController;
     SliceNavigationController::Pointer m_SliceNavigationController;
     CameraRotationController::Pointer m_CameraRotationController;
 
     //##Documentation
     //## @brief Sets m_CurrentWorldPlaneGeometry
-    virtual void SetCurrentWorldPlaneGeometry(PlaneGeometry *geometry2d);
+    virtual void SetCurrentWorldPlaneGeometry(const PlaneGeometry *geometry2d);
     /**
     * \deprecatedSince{2014_10} Please use SetCurrentWorldPlaneGeometry
     */
     DEPRECATED(void SetCurrentWorldGeometry2D(PlaneGeometry *geometry2d)) { SetCurrentWorldPlaneGeometry(geometry2d); };
     //##Documentation
     //## @brief Sets m_CurrentWorldGeometry
-    virtual void SetCurrentWorldGeometry(BaseGeometry *geometry);
+    virtual void SetCurrentWorldGeometry(const BaseGeometry *geometry);
 
   private:
     //##Documentation
     //## m_WorldTimeGeometry is set by SetWorldGeometry if the passed BaseGeometry 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_WorldTimeGeometry (if available)
     //## is used as m_CurrentWorldPlaneGeometry.
     //## \sa m_CurrentWorldPlaneGeometry
-    TimeGeometry::Pointer m_WorldTimeGeometry;
+    TimeGeometry::ConstPointer m_WorldTimeGeometry;
 
     //##Documentation
     //## Pointer to the current 3D-worldgeometry.
-    BaseGeometry::Pointer m_CurrentWorldGeometry;
+    BaseGeometry::ConstPointer 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.
     //## 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).
     PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
 
     //##Documentation
     //## Defines together with m_Slice which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_Slice;
     //##Documentation
     //## Defines together with m_TimeStep which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_TimeStep;
 
     //##Documentation
     //## @brief timestamp of last call of SetWorldGeometry
     itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
 
     //##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;
 
     //##Documentation
     //## @brief Tells if the displayed region should be shifted or rescaled if the render window is resized.
     bool m_KeepDisplayedRegion;
 
   protected:
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     //##Documentation
     //## Data object containing the m_CurrentWorldPlaneGeometry defined above.
     PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
 
     //##Documentation
     //## DataNode objects containing the m_CurrentWorldPlaneGeometryData defined above.
     DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
 
     //##Documentation
     //## @brief test only
     unsigned long m_CurrentWorldPlaneGeometryTransformTime;
 
     std::string m_Name;
 
     double m_Bounds[6];
 
     bool m_EmptyWorldGeometry;
 
     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;
 
     bool m_ConstrainZoomingAndPanning;
 
   public:
     void RemoveAllLocalStorages();
     void RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
     void UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
   };
 } // namespace mitk
 
 #endif /* BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4 */
diff --git a/Modules/Core/include/mitkDataStorage.h b/Modules/Core/include/mitkDataStorage.h
index 354233a415..55e63e9cd3 100644
--- a/Modules/Core/include/mitkDataStorage.h
+++ b/Modules/Core/include/mitkDataStorage.h
@@ -1,440 +1,440 @@
 /*===================================================================
 
 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 "itkSimpleFastMutexLock.h"
 #include "itkVectorContainer.h"
 #include "mitkDataNode.h"
 #include "mitkGeometry3D.h"
 #include "mitkMessage.h"
 #include <MitkCoreExports.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 MITKCORE_EXPORT DataStorage : public itk::Object
   {
   public:
     mitkClassMacroItkParent(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 nullptr or if the DataNode has already been added,
     //## an exception will be thrown.
     virtual void Add(mitk::DataNode *node, const mitk::DataStorage::SetOfObjects *parents = nullptr) = 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 = nullptr,
                                                   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 = nullptr,
                                                       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 = nullptr) 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 == nullptr)
         return nullptr;
       mitk::DataNode *n = this->GetNamedNode(name);
       if (n == nullptr)
         return nullptr;
       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 == nullptr)
         return nullptr;
       mitk::DataNode *n = this->GetNamedDerivedNode(name, sourceNode, onlyDirectDerivations);
       if (n == nullptr)
         return nullptr;
       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 nullptr
     //## @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::TimeGeometry::Pointer ComputeBoundingGeometry3D(const SetOfObjects *input,
+    mitk::TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const SetOfObjects *input,
                                                           const char *boolPropertyKey = nullptr,
                                                           const mitk::BaseRenderer *renderer = nullptr,
                                                           const char *boolPropertyKey2 = nullptr) const;
 
     //##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::TimeGeometry::Pointer ComputeBoundingGeometry3D(const char *boolPropertyKey = nullptr,
+    mitk::TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const char *boolPropertyKey = nullptr,
                                                           const mitk::BaseRenderer *renderer = nullptr,
                                                           const char *boolPropertyKey2 = nullptr) const;
 
     //##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::TimeGeometry::Pointer ComputeVisibleBoundingGeometry3D(const mitk::BaseRenderer *renderer = nullptr,
+    mitk::TimeGeometry::ConstPointer ComputeVisibleBoundingGeometry3D(const mitk::BaseRenderer *renderer = nullptr,
                                                                  const char *boolPropertyKey = nullptr);
 
     //##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 = nullptr,
                                                   const mitk::BaseRenderer *renderer = nullptr,
                                                   const char *boolPropertyKey2 = nullptr);
 
     //##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(const mitk::BaseRenderer *renderer = nullptr,
                                                          const char *boolPropertyKey = nullptr)
     {
       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,
                                        const 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(const 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
     ~DataStorage() override;
 
     //##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
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
   };
 } // namespace mitk
 
 #endif /* MITKDATASTORAGE_H_HEADER_INCLUDED_ */
diff --git a/Modules/Core/src/Controllers/mitkRenderingManager.cpp b/Modules/Core/src/Controllers/mitkRenderingManager.cpp
index d46ebe9f77..a92142ac93 100644
--- a/Modules/Core/src/Controllers/mitkRenderingManager.cpp
+++ b/Modules/Core/src/Controllers/mitkRenderingManager.cpp
@@ -1,744 +1,744 @@
 /*===================================================================
 
 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 "mitkBaseRenderer.h"
 #include "mitkCameraController.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkRenderingManagerFactory.h"
 
 #include <vtkRenderWindow.h>
 
 #include "mitkNumericTypes.h"
 #include <itkAffineGeometryFrame.h>
 #include <itkCommand.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkVtkPropRenderer.h>
 
 #include <algorithm>
 
 namespace mitk
 {
   itkEventMacroDefinition(FocusChangedEvent, itk::AnyEvent)
 
     RenderingManager::Pointer RenderingManager::s_Instance = nullptr;
   RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = nullptr;
 
   RenderingManager::RenderingManager()
     : m_UpdatePending(false),
       m_MaxLOD(1),
       m_LODIncreaseBlocked(false),
       m_LODAbortMechanismEnabled(false),
       m_ClippingPlaneEnabled(false),
       m_TimeNavigationController(SliceNavigationController::New()),
       m_DataStorage(nullptr),
       m_ConstrainedPanningZooming(true),
       m_FocusedRenderWindow(nullptr)
   {
     m_ShadingEnabled.assign(3, false);
     m_ShadingValues.assign(4, 0.0);
 
     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(nullptr);
 
       auto 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 == nullptr)
       return nullptr;
     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(nullptr);
 
       // 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))
     {
       auto 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);
       }
 
       auto rw_it =
         std::find(m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow);
 
       if (rw_it != m_AllRenderWindows.cend())
       {
         // Decrease reference count for proper destruction
         (*rw_it)->UnRegister(nullptr);
         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.cend())
     {
       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.cend())
     {
       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 crashes
     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.
       auto *vPR = dynamic_cast<mitk::VtkPropRenderer *>(mitk::BaseRenderer::GetInstance(renderWindow));
       if (vPR)
         vPR->PrepareRender();
       // Execute rendering
       renderWindow->Render();
     }
   }
 
   void RenderingManager::RequestUpdateAll(RequestType type)
   {
     RenderWindowList::const_iterator it;
     for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++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::const_iterator it;
     for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++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);
       }
     }
   }
 
   void RenderingManager::InitializeViewsByBoundingObjects(const DataStorage *ds)
   {
     if (!ds)
       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 = ds->GetSubset(pred);
     // calculate bounding geometry of these nodes
-    mitk::TimeGeometry::Pointer bounds = ds->ComputeBoundingGeometry3D(rs, "visible");
+    auto bounds = ds->ComputeBoundingGeometry3D(rs, "visible");
 
     // initialize the views to the bounding geometry
     this->InitializeViews(bounds);
   }
 
   // TODO_GOETZ
   // Remove old function, so only this one is working.
   bool RenderingManager::InitializeViews(const BaseGeometry *dataGeometry,
                                          RequestType type,
                                          bool preserveRoughOrientationInWorldSpace)
   {
     ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
     propTimeGeometry->Initialize(dynamic_cast<BaseGeometry *>(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;
 
     TimeGeometry::ConstPointer timeGeometry = dataGeometry;
     TimeGeometry::Pointer modifiedGeometry = nullptr;
     if (dataGeometry != nullptr)
     {
       modifiedGeometry = dataGeometry->Clone();
     }
 
     int warningLevel = vtkObject::GetGlobalWarningDisplay();
     vtkObject::GlobalWarningDisplayOff();
 
     if ((timeGeometry.IsNotNull()) &&
         (timeGeometry->GetBoundingBoxInWorld()->GetDiagonalLength2() > mitk::eps))
     {
       boundingBoxInitialized = true;
     }
 
     if (timeGeometry.IsNotNull())
     { // make sure bounding box has an extent bigger than zero in any direction
       // clone the input geometry
       // Old Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
       assert(modifiedGeometry.IsNotNull());
       for (TimeStepType step = 0; step < modifiedGeometry->CountTimeSteps(); ++step)
       {
         BaseGeometry::BoundsArrayType newBounds = modifiedGeometry->GetGeometryForTimeStep(step)->GetBounds();
         for (unsigned int dimension = 0; (2 * dimension) < newBounds.Size(); dimension++)
         {
           // check for equality but for an epsilon
           if (Equal(newBounds[2 * dimension], newBounds[2 * dimension + 1]))
           {
             newBounds[2 * dimension + 1] += 1;
             if (Equal(
                   newBounds[2 * dimension],
                   newBounds[2 * dimension + 1])) // newBounds will still be equal if values are beyond double precision
             {
               mitkThrow() << "One dimension of object data has zero length, please make sure you're not using numbers "
                              "beyond double precision as coordinates.";
             }
           }
         }
         modifiedGeometry->GetGeometryForTimeStep(step)->SetBounds(newBounds);
       }
     }
 
     timeGeometry = modifiedGeometry;
     RenderWindowList::const_iterator it;
     for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
     {
       mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(it->first);
 
       baseRenderer->SetConstrainZoomingAndPanning(m_ConstrainedPanningZooming);
 
       int id = baseRenderer->GetMapperID();
       if (((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) ||
            ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2))))
       {
         this->InternalViewInitialization(baseRenderer, timeGeometry, boundingBoxInitialized, id);
       }
     }
 
     if (boundingBoxInitialized)
     {
       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::const_iterator it;
     for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++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 BaseGeometry *geometry,
                                         bool initializeGlobalTimeSNC)
   {
     ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
     propTimeGeometry->Initialize(dynamic_cast<BaseGeometry *>(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 != nullptr) &&
         (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->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::TimeGeometry *geometry,
                                                     bool boundingBoxInitialized,
                                                     int mapperID)
   {
     mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
 
     // Re-initialize view direction
     nc->SetViewDirectionToDefault();
 
     if (boundingBoxInitialized)
     {
       // Set geometry for NC
       nc->SetInputWorldTimeGeometry(geometry);
       nc->Update();
 
       if (mapperID == BaseRenderer::Standard2D)
       {
         // For 2D SNCs, steppers are set so that the cross is centered
         // in the image
         nc->GetSlice()->SetPos(nc->GetSlice()->GetSteps() / 2);
       }
 
       baseRenderer->GetCameraController()->SetViewToAnterior();
       baseRenderer->GetCameraController()->Fit();
     }
     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::const_iterator it;
     int i = 0;
     for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it, ++i)
     {
       if (it->second == RENDERING_REQUESTED)
       {
         this->ForceImmediateUpdate(it->first);
       }
     }
   }
 
   void RenderingManager::RenderingStartCallback(vtkObject *caller, unsigned long, void *, void *)
   {
     auto *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 *)
   {
     auto *renderWindow = dynamic_cast<vtkRenderWindow *>(caller);
     mitk::RenderingManager *renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
 
     if (renman->m_LODAbortMechanismEnabled)
     {
       auto *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 *)
   {
     auto *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.cbegin(); it != m_RenderWindowList.cend(); ++it)
     {
       if (it->second == RENDERING_INPROGRESS)
       {
         return true;
       }
     }
     return false;
   }
 
   void RenderingManager::AbortRendering()
   {
     RenderWindowList::const_iterator it;
     for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
     {
       if (it->second == RENDERING_INPROGRESS)
       {
         it->first->SetAbortRender(true);
         m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true;
       }
     }
   }
 
   int RenderingManager::GetNextLOD(BaseRenderer *renderer)
   {
     if (renderer != nullptr)
     {
       return m_NextLODMap[renderer];
     }
     else
     {
       return 0;
     }
   }
 
   void RenderingManager::ExecutePendingHighResRenderingRequest()
   {
     RenderWindowList::const_iterator it;
     for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++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::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 != nullptr)
     {
       m_DataStorage = storage;
 
       RenderingManager::RenderWindowVector::const_iterator iter;
       for (iter = m_AllRenderWindows.cbegin(); iter < m_AllRenderWindows.cend(); ++iter)
       {
         mitk::BaseRenderer::GetInstance((*iter))->SetDataStorage(m_DataStorage.GetPointer());
       }
     }
   }
 
   mitk::DataStorage *RenderingManager::GetDataStorage() { return m_DataStorage; }
   void RenderingManager::SetRenderWindowFocus(vtkRenderWindow *focusWindow)
   {
     if (focusWindow != m_FocusedRenderWindow)
     {
       if (!focusWindow || (m_RenderWindowList.find(focusWindow) != m_RenderWindowList.cend()))
       {
         m_FocusedRenderWindow = focusWindow;
         this->InvokeEvent(FocusChangedEvent());
         return;
       }
 
       MITK_ERROR << "Tried to set a RenderWindow that does not exist.";
     }
   }
 
   // Create and register generic RenderingManagerFactory.
   TestingRenderingManagerFactory renderingManagerFactory;
 } // namespace
diff --git a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
index 9939a7ee28..c2322cb5c2 100644
--- a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
@@ -1,293 +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 <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() )
   {
     for ( auto pos = m_MaximumTimePoints.cbegin(); pos != m_MaximumTimePoints.cend(); ++pos )
     {
       if (timePoint < *pos)
       {
         result = pos - m_MaximumTimePoints.begin();
         break;
       }
     }
   }
 
   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;
   }
 }
diff --git a/Modules/Core/src/DataManagement/mitkDataStorage.cpp b/Modules/Core/src/DataManagement/mitkDataStorage.cpp
index f548fb9ced..43a69e91bd 100644
--- a/Modules/Core/src/DataManagement/mitkDataStorage.cpp
+++ b/Modules/Core/src/DataManagement/mitkDataStorage.cpp
@@ -1,518 +1,516 @@
 /*===================================================================
 
 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 "itkCommand.h"
 #include "itkMutexLockHolder.h"
 #include "mitkDataNode.h"
 #include "mitkGroupTagProperty.h"
 #include "mitkImage.h"
 #include "mitkNodePredicateBase.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkProperties.h"
+#include "mitkArbitraryTimeGeometry.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();
   if (parent != nullptr) //< Return empty set if parent is null
     parents->InsertElement(0, parent);
   this->Add(node, parents);
 }
 
 void mitk::DataStorage::Remove(const mitk::DataStorage::SetOfObjects *nodes)
 {
   if (nodes == nullptr)
     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 == nullptr)
     return nullptr;
 
   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 nullptr;
 }
 
 mitk::DataNode *mitk::DataStorage::GetNode(const NodePredicateBase *condition) const
 {
   if (condition == nullptr)
     return nullptr;
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(condition);
   if (rs->Size() >= 1)
     return rs->GetElement(0);
   else
     return nullptr;
 }
 
 mitk::DataNode *mitk::DataStorage::GetNamedDerivedNode(const char *name,
                                                        const mitk::DataNode *sourceNode,
                                                        bool onlyDirectDerivations) const
 {
   if (name == nullptr)
     return nullptr;
 
   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 nullptr;
 }
 
 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() != nullptr)
       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 == nullptr)
     return nullptr;
 
   mitk::DataStorage::SetOfObjects::Pointer result = mitk::DataStorage::SetOfObjects::New();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = set->Begin(); it != set->End(); it++)
     if (condition == nullptr ||
         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 (auto propIt = pl->GetMap()->begin(); propIt != pl->GetMap()->end();
          ++propIt)
       if (dynamic_cast<mitk::GroupTagProperty *>(propIt->second.GetPointer()) != nullptr)
         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 auto *_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 auto *_Node = dynamic_cast<const mitk::DataNode *>(caller);
   if (_Node)
   {
     const auto *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
   auto *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
   auto *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::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D(const SetOfObjects *input,
+mitk::TimeGeometry::ConstPointer mitk::DataStorage::ComputeBoundingGeometry3D(const SetOfObjects *input,
                                                                          const char *boolPropertyKey,
                                                                          const mitk::BaseRenderer *renderer,
                                                                          const char *boolPropertyKey2) const
 {
   if (input == nullptr)
     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(itk::NumericTraits<mitk::ScalarType>::max());
 
-  ScalarType stmin, stmax;
-  stmin = itk::NumericTraits<mitk::ScalarType>::NonpositiveMin();
-  stmax = itk::NumericTraits<mitk::ScalarType>::max();
+  ScalarType stmax = itk::NumericTraits<mitk::ScalarType>::max();
+  ScalarType stmin = itk::NumericTraits<mitk::ScalarType>::NonpositiveMin();
 
-  ScalarType minimalIntervallSize = stmax;
-  ScalarType minimalTime = stmax;
+  std::set<ScalarType> existingTimePoints;
   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() != nullptr) && (node->GetData()->IsEmpty() == false) &&
         node->IsOn(boolPropertyKey, renderer) && node->IsOn(boolPropertyKey2, renderer))
     {
       const TimeGeometry *timeGeometry = node->GetData()->GetUpdatedTimeGeometry();
 
       if (timeGeometry != nullptr)
       {
         // bounding box (only if non-zero)
         BoundingBox::BoundsArrayType itkBounds = timeGeometry->GetBoundingBoxInWorld()->GetBounds();
         if (itkBounds == itkBoundsZero)
         {
           continue;
         }
 
         unsigned char i;
         for (i = 0; i < 8; ++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);
           }
         }
         try
         {
           // time bounds
           // iterate over all time steps
           // Attention: Objects with zero bounding box are not respected in time bound calculation
           for (TimeStepType i = 0; i < timeGeometry->CountTimeSteps(); i++)
           {
             // We must not use 'node->GetData()->GetGeometry(i)->GetSpacing()' here, as it returns the spacing
             // in its original space, which, in case of an image geometry, can have the values in different
             // order than in world space. For the further calculations, we need to have the spacing values
             // in world coordinate order (sag-cor-ax).
             Vector3D spacing;
             spacing.Fill(1.0);
             node->GetData()->GetGeometry(i)->IndexToWorld(spacing, spacing);
             for (int axis = 0; axis < 3; ++ axis)
             {
               ScalarType space = std::abs(spacing[axis]);
               if (space < minSpacing[axis])
               {
                 minSpacing[axis] = space;
               }
             }
 
-            const TimeBounds &curTimeBounds = node->GetData()->GetTimeGeometry()->GetTimeBounds(i);
-            // get the minimal time of all objects in the DataStorage
-            if ((curTimeBounds[0] < minimalTime) && (curTimeBounds[0] > stmin))
+            const auto curTimeBounds = timeGeometry->GetTimeBounds(i);
+            if ((curTimeBounds[0] > stmin) && (curTimeBounds[0] < stmax))
             {
-              minimalTime = curTimeBounds[0];
+              existingTimePoints.insert(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] < minimalIntervallSize)
-            {
-              minimalIntervallSize = curTimeBounds[1] - curTimeBounds[0];
+               maximalTime = curTimeBounds[1];
             }
           }
         }
         catch (itk::ExceptionObject &e)
         {
           MITK_ERROR << e << std::endl;
         }
       }
     }
   }
 
   BoundingBox::Pointer result = BoundingBox::New();
   result->SetPoints(pointscontainer);
   result->ComputeBoundingBox();
 
   // 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
+  if (existingTimePoints.empty()) // make sure that there is at least one time sliced geometry in the data storage
   {
-    minimalTime = 0;
-    maximalTime = 1;
-    minimalIntervallSize = 1;
+    existingTimePoints.insert(0.0);
+    maximalTime = 1.0;
   }
-  numberOfTimeSteps = static_cast<unsigned int>((maximalTime - minimalTime) / minimalIntervallSize);
 
-  TimeGeometry::Pointer timeGeometry = nullptr;
+  ArbitraryTimeGeometry::Pointer timeGeometry = nullptr;
   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();
     AffineTransform3D::OutputVectorType offset;
     for (int i = 0; i < 3; ++i)
     {
       offset[i] = bounds[i * 2];
       bounds[i * 2] = 0.0;
       bounds[i * 2 + 1] = (bounds[i * 2 + 1] - offset[i]) / minSpacing[i];
     }
     geometry->GetIndexToWorldTransform()->SetOffset(offset);
     geometry->SetBounds(bounds);
     geometry->SetSpacing(minSpacing);
+
     // Initialize the time sliced geometry
-    timeGeometry = ProportionalTimeGeometry::New();
-    dynamic_cast<ProportionalTimeGeometry *>(timeGeometry.GetPointer())->Initialize(geometry, numberOfTimeSteps);
-    dynamic_cast<ProportionalTimeGeometry *>(timeGeometry.GetPointer())->SetFirstTimePoint(minimalTime);
-    dynamic_cast<ProportionalTimeGeometry *>(timeGeometry.GetPointer())->SetStepDuration(minimalIntervallSize);
+    auto tsIterator = existingTimePoints.cbegin();
+    auto tsPredecessor = tsIterator++;
+    auto tsEnd = existingTimePoints.cend();
+    timeGeometry = ArbitraryTimeGeometry::New();
+    for (; tsIterator != tsEnd; ++tsIterator, ++tsPredecessor)
+    {
+      timeGeometry->AppendNewTimeStep(geometry, *tsPredecessor, *tsIterator);
+    }
+    timeGeometry->AppendNewTimeStep(geometry, *tsPredecessor, maximalTime);
+
+    timeGeometry->Update();
   }
-  return timeGeometry;
+  return timeGeometry.GetPointer();
 }
 
-mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D(const char *boolPropertyKey,
+mitk::TimeGeometry::ConstPointer mitk::DataStorage::ComputeBoundingGeometry3D(const char *boolPropertyKey,
                                                                          const mitk::BaseRenderer *renderer,
                                                                          const char *boolPropertyKey2) const
 {
   return this->ComputeBoundingGeometry3D(this->GetAll(), boolPropertyKey, renderer, boolPropertyKey2);
 }
 
-mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeVisibleBoundingGeometry3D(const mitk::BaseRenderer *renderer,
+mitk::TimeGeometry::ConstPointer mitk::DataStorage::ComputeVisibleBoundingGeometry3D(const mitk::BaseRenderer *renderer,
                                                                                 const char *boolPropertyKey)
 {
   return ComputeBoundingGeometry3D("visible", renderer, boolPropertyKey);
 }
 
 mitk::BoundingBox::Pointer mitk::DataStorage::ComputeBoundingBox(const char *boolPropertyKey,
                                                                  const 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() != nullptr) && (node->GetData()->IsEmpty() == false) &&
         node->IsOn(boolPropertyKey, renderer) && node->IsOn(boolPropertyKey2, renderer))
     {
       const TimeGeometry *geometry = node->GetData()->GetUpdatedTimeGeometry();
       if (geometry != nullptr)
       {
         // bounding box (only if non-zero)
         BoundingBox::BoundsArrayType itkBounds = geometry->GetBoundingBoxInWorld()->GetBounds();
         if (itkBounds == itkBoundsZero)
         {
           continue;
         }
 
         unsigned char i;
         for (i = 0; i < 8; ++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,
                                                       const mitk::BaseRenderer *renderer,
                                                       const char *boolPropertyKey2)
 {
   TimeBounds timeBounds;
 
   ScalarType stmin, stmax, cur;
 
   stmin = itk::NumericTraits<mitk::ScalarType>::NonpositiveMin();
   stmax = itk::NumericTraits<mitk::ScalarType>::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() != nullptr) && (node->GetData()->IsEmpty() == false) &&
         node->IsOn(boolPropertyKey, renderer) && node->IsOn(boolPropertyKey2, renderer))
     {
       const TimeGeometry *geometry = node->GetData()->GetUpdatedTimeGeometry();
       if (geometry != nullptr)
       {
         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/Modules/Core/src/Rendering/mitkBaseRenderer.cpp b/Modules/Core/src/Rendering/mitkBaseRenderer.cpp
index a5d6642f85..0f9271ca89 100644
--- a/Modules/Core/src/Rendering/mitkBaseRenderer.cpp
+++ b/Modules/Core/src/Rendering/mitkBaseRenderer.cpp
@@ -1,780 +1,780 @@
 /*===================================================================
 
  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"
 
 // Geometries
 #include "mitkPlaneGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 // Controllers
 #include "mitkCameraController.h"
 #include "mitkCameraRotationController.h"
 #include "mitkSliceNavigationController.h"
 
 #include "mitkVtkLayerController.h"
 
 #include "mitkInteractionConst.h"
 #include "mitkProperties.h"
 #include "mitkWeakPointerProperty.h"
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkLinearTransform.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
 
 mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap;
 
 mitk::BaseRenderer *mitk::BaseRenderer::GetInstance(vtkRenderWindow *renWin)
 {
   for (auto mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); ++mapit)
   {
     if ((*mapit).first == renWin)
       return (*mapit).second;
   }
   return nullptr;
 }
 
 void mitk::BaseRenderer::AddInstance(vtkRenderWindow *renWin, BaseRenderer *baseRenderer)
 {
   if (renWin == nullptr || baseRenderer == nullptr)
     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)
 {
   auto mapit = baseRendererMap.find(renWin);
   if (mapit != baseRendererMap.end())
     baseRendererMap.erase(mapit);
 }
 
 mitk::BaseRenderer *mitk::BaseRenderer::GetByName(const std::string &name)
 {
   for (auto mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); ++mapit)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).second;
   }
   return nullptr;
 }
 
 vtkRenderWindow *mitk::BaseRenderer::GetRenderWindowByName(const std::string &name)
 {
   for (auto mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); ++mapit)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).first;
   }
   return nullptr;
 }
 
 mitk::BaseRenderer::BaseRenderer(const char *name,
                                  vtkRenderWindow *renWin,
                                  mitk::RenderingManager *rm,
                                  RenderingMode::Type renderingMode)
   : m_RenderWindow(nullptr),
     m_VtkRenderer(nullptr),
     m_MapperID(defaultMapper),
     m_DataStorage(nullptr),
     m_RenderingManager(rm),
     m_LastUpdateTime(0),
     m_CameraController(nullptr),
     m_SliceNavigationController(nullptr),
     m_CameraRotationController(nullptr),
     m_WorldTimeGeometry(nullptr),
     m_CurrentWorldGeometry(nullptr),
     m_CurrentWorldPlaneGeometry(nullptr),
     m_Slice(0),
     m_TimeStep(),
     m_CurrentWorldPlaneGeometryUpdateTime(),
     m_TimeStepUpdateTime(),
     m_KeepDisplayedRegion(true),
     m_CurrentWorldPlaneGeometryData(nullptr),
     m_CurrentWorldPlaneGeometryNode(nullptr),
     m_CurrentWorldPlaneGeometryTransformTime(0),
     m_Name(name),
     m_EmptyWorldGeometry(true),
     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 != nullptr)
   {
     m_Name = name;
   }
   else
   {
     m_Name = "unnamed renderer";
     itkWarningMacro(<< "Created unnamed renderer. Bad for serialization. Please choose a name.");
   }
 
   if (renWin != nullptr)
   {
     m_RenderWindow = renWin;
     m_RenderWindow->Register(nullptr);
   }
   else
   {
     itkWarningMacro(<< "Created mitkBaseRenderer without vtkRenderWindow present.");
   }
   // instances.insert( this );
 
   // adding this BaseRenderer to the List of all BaseRenderer
 
   m_BindDispatcherInteractor = new mitk::BindDispatcherInteractor(GetName());
 
   WeakPointerProperty::Pointer rendererProp = WeakPointerProperty::New((itk::Object *)this);
 
   m_CurrentWorldPlaneGeometry = mitk::PlaneGeometry::New();
 
   m_CurrentWorldPlaneGeometryData = mitk::PlaneGeometryData::New();
   m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
   m_CurrentWorldPlaneGeometryNode = mitk::DataNode::New();
   m_CurrentWorldPlaneGeometryNode->SetData(m_CurrentWorldPlaneGeometryData);
   m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
   m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
 
   m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
   m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
 
   m_CurrentWorldPlaneGeometryTransformTime = m_CurrentWorldPlaneGeometryNode->GetVtkTransform()->GetMTime();
 
   mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::SliceNavigationController::New();
   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();
 
   m_CameraController = mitk::CameraController::New();
   m_CameraController->SetRenderer(this);
 
   m_VtkRenderer = vtkRenderer::New();
 
   if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == nullptr)
   {
     mitk::VtkLayerController::AddInstance(m_RenderWindow, m_VtkRenderer);
   }
   mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
 }
 
 mitk::BaseRenderer::~BaseRenderer()
 {
   if (m_VtkRenderer != nullptr)
   {
     m_VtkRenderer->Delete();
     m_VtkRenderer = nullptr;
   }
 
   if (m_CameraController.IsNotNull())
     m_CameraController->SetRenderer(nullptr);
 
   mitk::VtkLayerController::RemoveInstance(m_RenderWindow);
 
   RemoveAllLocalStorages();
 
   m_DataStorage = nullptr;
 
   if (m_BindDispatcherInteractor != nullptr)
   {
     delete m_BindDispatcherInteractor;
   }
 
   if (m_RenderWindow != nullptr)
   {
     m_RenderWindow->Delete();
     m_RenderWindow = nullptr;
   }
 }
 
 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();
 }
 
 void mitk::BaseRenderer::UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
 {
   m_RegisteredLocalStorageHandlers.remove(lsh);
 }
 
 void mitk::BaseRenderer::SetDataStorage(DataStorage *storage)
 {
   if (storage != m_DataStorage && storage != nullptr)
   {
     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)
 {
   this->m_RenderWindow->SetSize(w, h);
 }
 
 void mitk::BaseRenderer::InitRenderer(vtkRenderWindow *renderwindow)
 {
   if (m_RenderWindow != renderwindow)
   {
     if (m_RenderWindow != nullptr)
     {
       m_RenderWindow->Delete();
     }
     m_RenderWindow = renderwindow;
     if (m_RenderWindow != nullptr)
     {
       m_RenderWindow->Register(nullptr);
     }
   }
   RemoveAllLocalStorages();
 
   if (m_CameraController.IsNotNull())
   {
     m_CameraController->SetRenderer(this);
   }
 }
 
 void mitk::BaseRenderer::InitSize(int w, int h)
 {
   this->m_RenderWindow->SetSize(w, h);
 }
 
 void mitk::BaseRenderer::SetSlice(unsigned int slice)
 {
   if (m_Slice != slice)
   {
     m_Slice = slice;
     if (m_WorldTimeGeometry.IsNotNull())
     {
       // get world geometry which may be rotated, for the current time step
       SlicedGeometry3D *slicedWorldGeometry =
         dynamic_cast<SlicedGeometry3D *>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != nullptr)
       {
         // if slice position is part of the world geometry...
         if (m_Slice >= slicedWorldGeometry->GetSlices())
           // set the current worldplanegeomety as the selected 2D slice of the world geometry
           m_Slice = slicedWorldGeometry->GetSlices() - 1;
         SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 void mitk::BaseRenderer::SetTimeStep(unsigned int timeStep)
 {
   if (m_TimeStep != timeStep)
   {
     m_TimeStep = timeStep;
     m_TimeStepUpdateTime.Modified();
 
     if (m_WorldTimeGeometry.IsNotNull())
     {
       if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
         m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
       SlicedGeometry3D *slicedWorldGeometry =
         dynamic_cast<SlicedGeometry3D *>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != nullptr)
       {
         SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 int mitk::BaseRenderer::GetTimeStep(const mitk::BaseData *data) const
 {
   if ((data == nullptr) || (data->IsInitialized() == false))
   {
     return -1;
   }
   return data->GetTimeGeometry()->TimePointToTimeStep(GetTime());
 }
 
 mitk::ScalarType mitk::BaseRenderer::GetTime() const
 {
   if (m_WorldTimeGeometry.IsNull())
   {
     return 0;
   }
   else
   {
     ScalarType timeInMS = m_WorldTimeGeometry->TimeStepToTimePoint(GetTimeStep());
     if (timeInMS == itk::NumericTraits<mitk::ScalarType>::NonpositiveMin())
       return 0;
     else
       return timeInMS;
   }
 }
 
-void mitk::BaseRenderer::SetWorldTimeGeometry(mitk::TimeGeometry *geometry)
+void mitk::BaseRenderer::SetWorldTimeGeometry(const mitk::TimeGeometry *geometry)
 {
   assert(geometry != nullptr);
 
   itkDebugMacro("setting WorldTimeGeometry to " << geometry);
   if (m_WorldTimeGeometry != geometry)
   {
     if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldTimeGeometry = geometry;
     itkDebugMacro("setting WorldTimeGeometry to " << m_WorldTimeGeometry);
 
     if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
       m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
 
     BaseGeometry *geometry3d;
     geometry3d = m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep);
     SetWorldGeometry3D(geometry3d);
   }
 }
 
-void mitk::BaseRenderer::SetWorldGeometry3D(mitk::BaseGeometry *geometry)
+void mitk::BaseRenderer::SetWorldGeometry3D(const mitk::BaseGeometry *geometry)
 {
   itkDebugMacro("setting WorldGeometry3D to " << geometry);
 
   if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
     return;
-  SlicedGeometry3D *slicedWorldGeometry;
-  slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(geometry);
+  const SlicedGeometry3D *slicedWorldGeometry;
+  slicedWorldGeometry = dynamic_cast<const SlicedGeometry3D *>(geometry);
 
-  PlaneGeometry::Pointer geometry2d;
+  PlaneGeometry::ConstPointer geometry2d;
   if (slicedWorldGeometry != nullptr)
   {
     if (m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
       m_Slice = slicedWorldGeometry->GetSlices() - 1;
     geometry2d = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
     if (geometry2d.IsNull())
     {
       PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
       plane->InitializeStandardPlane(slicedWorldGeometry);
       geometry2d = plane;
     }
     SetCurrentWorldGeometry(slicedWorldGeometry);
   }
   else
   {
-    geometry2d = dynamic_cast<PlaneGeometry *>(geometry);
+    geometry2d = dynamic_cast<const PlaneGeometry *>(geometry);
     if (geometry2d.IsNull())
     {
       PlaneGeometry::Pointer plane = PlaneGeometry::New();
       plane->InitializeStandardPlane(geometry);
       geometry2d = plane;
     }
     SetCurrentWorldGeometry(geometry);
   }
   SetCurrentWorldPlaneGeometry(geometry2d); // calls Modified()
 
   if (m_CurrentWorldPlaneGeometry.IsNull())
     itkWarningMacro("m_CurrentWorldPlaneGeometry is nullptr");
 }
 
-void mitk::BaseRenderer::SetCurrentWorldPlaneGeometry(mitk::PlaneGeometry *geometry2d)
+void mitk::BaseRenderer::SetCurrentWorldPlaneGeometry(const mitk::PlaneGeometry *geometry2d)
 {
   if (m_CurrentWorldPlaneGeometry != geometry2d)
   {
-    m_CurrentWorldPlaneGeometry = geometry2d;
+    m_CurrentWorldPlaneGeometry = geometry2d->Clone();
     m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
     m_CurrentWorldPlaneGeometryUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SendUpdateSlice()
 {
   m_CurrentWorldPlaneGeometryUpdateTime.Modified();
 }
 
 int *mitk::BaseRenderer::GetSize() const
 {
   return this->m_RenderWindow->GetSize();
 }
 
 int *mitk::BaseRenderer::GetViewportSize() const
 {
   return this->m_VtkRenderer->GetSize();
 }
 
-void mitk::BaseRenderer::SetCurrentWorldGeometry(mitk::BaseGeometry *geometry)
+void mitk::BaseRenderer::SetCurrentWorldGeometry(const mitk::BaseGeometry *geometry)
 {
   m_CurrentWorldGeometry = geometry;
   if (geometry == nullptr)
   {
     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(nullptr);
   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::SetGeometry(const itk::EventObject &geometrySendEvent)
 {
   const auto *sendEvent =
     dynamic_cast<const SliceNavigationController::GeometrySendEvent *>(&geometrySendEvent);
 
   assert(sendEvent != nullptr);
   SetWorldTimeGeometry(sendEvent->GetTimeGeometry());
 }
 
 void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject &geometryUpdateEvent)
 {
   const auto *updateEvent =
     dynamic_cast<const SliceNavigationController::GeometryUpdateEvent *>(&geometryUpdateEvent);
 
   if (updateEvent == nullptr)
     return;
 
   if (m_CurrentWorldGeometry.IsNotNull())
   {
-    auto *slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(m_CurrentWorldGeometry.GetPointer());
+    auto *slicedWorldGeometry = dynamic_cast<const SlicedGeometry3D *>(m_CurrentWorldGeometry.GetPointer());
     if (slicedWorldGeometry)
     {
       PlaneGeometry *geometry2D = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
 
       SetCurrentWorldPlaneGeometry(geometry2D); // calls Modified()
     }
   }
 }
 
 void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject &geometrySliceEvent)
 {
   const auto *sliceEvent =
     dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
 
   assert(sliceEvent != nullptr);
   SetSlice(sliceEvent->GetPos());
 }
 
 void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject &geometryTimeEvent)
 {
   const auto *timeEvent =
     dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
 
   assert(timeEvent != nullptr);
   SetTimeStep(timeEvent->GetPos());
 }
 
 const double *mitk::BaseRenderer::GetBounds() const
 {
   return m_Bounds;
 }
 
 void mitk::BaseRenderer::DrawOverlayMouse(mitk::Point2D &itkNotUsed(p2d))
 {
   MITK_INFO << "BaseRenderer::DrawOverlayMouse()- should be inconcret implementation OpenGLRenderer." << std::endl;
 }
 
 void mitk::BaseRenderer::RequestUpdate()
 {
   SetConstrainZoomingAndPanning(true);
   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 == nullptr)
     return;
 
   // copy worldgeometry
   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);
   }
 }
 
 void mitk::BaseRenderer::DisplayToWorld(const Point2D &displayPoint, Point3D &worldIndex) const
 {
   if (m_MapperID == BaseRenderer::Standard2D)
   {
     double display[3], *world;
 
     // For the rigth z-position in display coordinates, take the focal point, convert it to display and use it for
     // correct depth.
     double *displayCoord;
     double cameraFP[4];
     // Get camera focal point and position. Convert to display (screen)
     // coordinates. We need a depth value for z-buffer.
     this->GetVtkRenderer()->GetActiveCamera()->GetFocalPoint(cameraFP);
     cameraFP[3] = 0.0;
     this->GetVtkRenderer()->SetWorldPoint(cameraFP[0], cameraFP[1], cameraFP[2], cameraFP[3]);
     this->GetVtkRenderer()->WorldToDisplay();
     displayCoord = this->GetVtkRenderer()->GetDisplayPoint();
 
     // now convert the display point to world coordinates
     display[0] = displayPoint[0];
     display[1] = displayPoint[1];
     display[2] = displayCoord[2];
 
     this->GetVtkRenderer()->SetDisplayPoint(display);
     this->GetVtkRenderer()->DisplayToWorld();
     world = this->GetVtkRenderer()->GetWorldPoint();
 
     for (int i = 0; i < 3; i++)
     {
       worldIndex[i] = world[i] / world[3];
     }
   }
   else if (m_MapperID == BaseRenderer::Standard3D)
   {
     PickWorldPoint(
       displayPoint,
       worldIndex); // Seems to be the same code as above, but subclasses may contain different implementations.
   }
 
   return;
 }
 
 void mitk::BaseRenderer::DisplayToPlane(const Point2D &displayPoint, Point2D &planePointInMM) const
 {
   if (m_MapperID == BaseRenderer::Standard2D)
   {
     Point3D worldPoint;
     this->DisplayToWorld(displayPoint, worldPoint);
     this->m_CurrentWorldPlaneGeometry->Map(worldPoint, planePointInMM);
   }
   else if (m_MapperID == BaseRenderer::Standard3D)
   {
     MITK_WARN << "No conversion possible with 3D mapper.";
     return;
   }
 
   return;
 }
 
 void mitk::BaseRenderer::WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const
 {
   double world[4], *display;
 
   world[0] = worldIndex[0];
   world[1] = worldIndex[1];
   world[2] = worldIndex[2];
   world[3] = 1.0;
 
   this->GetVtkRenderer()->SetWorldPoint(world);
   this->GetVtkRenderer()->WorldToDisplay();
   display = this->GetVtkRenderer()->GetDisplayPoint();
 
   displayPoint[0] = display[0];
   displayPoint[1] = display[1];
 
   return;
 }
 
 void mitk::BaseRenderer::WorldToView(const mitk::Point3D &worldIndex, mitk::Point2D &viewPoint) const
 {
   double world[4], *view;
 
   world[0] = worldIndex[0];
   world[1] = worldIndex[1];
   world[2] = worldIndex[2];
   world[3] = 1.0;
 
   this->GetVtkRenderer()->SetWorldPoint(world);
   this->GetVtkRenderer()->WorldToView();
   view = this->GetVtkRenderer()->GetViewPoint();
   this->GetVtkRenderer()->ViewToNormalizedViewport(view[0], view[1], view[2]);
 
   viewPoint[0] = view[0] * this->GetViewportSize()[0];
   viewPoint[1] = view[1] * this->GetViewportSize()[1];
 
   return;
 }
 
 void mitk::BaseRenderer::PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const
 {
   Point3D worldPoint;
   this->m_CurrentWorldPlaneGeometry->Map(planePointInMM, worldPoint);
   this->WorldToDisplay(worldPoint, displayPoint);
 
   return;
 }
 
 void mitk::BaseRenderer::PlaneToView(const Point2D &planePointInMM, Point2D &viewPoint) const
 {
   Point3D worldPoint;
   this->m_CurrentWorldPlaneGeometry->Map(planePointInMM, worldPoint);
   this->WorldToView(worldPoint,viewPoint);
 
   return;
 }
 
 double mitk::BaseRenderer::GetScaleFactorMMPerDisplayUnit() const
 {
   if (this->GetMapperID() == BaseRenderer::Standard2D)
   {
     // GetParallelScale returns half of the height of the render window in mm.
     // Divided by the half size of the Display size in pixel givest the mm per pixel.
     return this->GetVtkRenderer()->GetActiveCamera()->GetParallelScale() * 2.0 / GetViewportSize()[1];
   }
   else
     return 1.0;
 }
 
 mitk::Point2D mitk::BaseRenderer::GetDisplaySizeInMM() const
 {
   Point2D dispSizeInMM;
   dispSizeInMM[0] = GetSizeX() * GetScaleFactorMMPerDisplayUnit();
   dispSizeInMM[1] = GetSizeY() * GetScaleFactorMMPerDisplayUnit();
   return dispSizeInMM;
 }
 
 mitk::Point2D mitk::BaseRenderer::GetViewportSizeInMM() const
 {
   Point2D dispSizeInMM;
   dispSizeInMM[0] = GetViewportSize()[0] * GetScaleFactorMMPerDisplayUnit();
   dispSizeInMM[1] = GetViewportSize()[1] * GetScaleFactorMMPerDisplayUnit();
   return dispSizeInMM;
 }
 
 mitk::Point2D mitk::BaseRenderer::GetOriginInMM() const
 {
   Point2D originPx;
   originPx[0] = m_VtkRenderer->GetOrigin()[0];
   originPx[1] = m_VtkRenderer->GetOrigin()[1];
   Point2D displayGeometryOriginInMM;
   DisplayToPlane(originPx, displayGeometryOriginInMM); // top left of the render window (Origin)
   return displayGeometryOriginInMM;
 }
 
 void mitk::BaseRenderer::SetConstrainZoomingAndPanning(bool constrain)
 {
   m_ConstrainZoomingAndPanning = constrain;
   if (m_ConstrainZoomingAndPanning)
   {
     this->GetCameraController()->AdjustCameraToPlane();
   }
 }
 
 mitk::Point3D mitk::BaseRenderer::Map2DRendererPositionTo3DWorldPosition(const Point2D &mousePosition) const
 {
   // DEPRECATED: Map2DRendererPositionTo3DWorldPosition is deprecated. use DisplayToWorldInstead
   Point3D position;
   DisplayToWorld(mousePosition, position);
   return position;
 }
 
 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 << " CurrentWorldPlaneGeometry: ";
   if (m_CurrentWorldPlaneGeometry.IsNull())
     os << "nullptr" << std::endl;
   else
     m_CurrentWorldPlaneGeometry->Print(os, indent);
 
   os << indent << " CurrentWorldPlaneGeometryUpdateTime: " << m_CurrentWorldPlaneGeometryUpdateTime << std::endl;
   os << indent << " CurrentWorldPlaneGeometryTransformTime: " << m_CurrentWorldPlaneGeometryTransformTime << std::endl;
 
   Superclass::PrintSelf(os, indent);
 }
diff --git a/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp b/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp
index e1e62686a8..4b3274ac0f 100644
--- a/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp
+++ b/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp
@@ -1,680 +1,680 @@
 /*===================================================================
 
 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 "mitkCameraController.h"
 #include "mitkImageVtkMapper2D.h"
 #include "mitkMapper.h"
 #include "mitkPlaneGeometryDataVtkMapper3D.h"
 #include "mitkVtkMapper.h"
 
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkGeometry3D.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkLevelWindow.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkRenderingManager.h>
 #include <mitkSurface.h>
 #include <mitkVtkInteractorStyle.h>
 
 // VTK
 #include <vtkAssemblyNode.h>
 #include <vtkAssemblyPath.h>
 #include <vtkCamera.h>
 #include <vtkCellPicker.h>
 #include <vtkInteractorStyleTrackballCamera.h>
 #include <vtkLight.h>
 #include <vtkLightKit.h>
 #include <vtkLinearTransform.h>
 #include <vtkMapper.h>
 #include <vtkPointPicker.h>
 #include <vtkProp.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
 #include <vtkRendererCollection.h>
 #include <vtkSmartPointer.h>
 #include <vtkTextActor.h>
 #include <vtkTextProperty.h>
 #include <vtkTransform.h>
 #include <vtkWorldPointPicker.h>
 
 mitk::VtkPropRenderer::VtkPropRenderer(const char *name,
                                        vtkRenderWindow *renWin,
                                        mitk::RenderingManager *rm,
                                        mitk::BaseRenderer::RenderingMode::Type renderingMode)
   : BaseRenderer(name, renWin, rm, renderingMode), 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::PlaneGeometryDataVtkMapper3D::Pointer geometryMapper = mitk::PlaneGeometryDataVtkMapper3D::New();
   m_CurrentWorldPlaneGeometryMapper = geometryMapper;
   m_CurrentWorldPlaneGeometryNode->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 != nullptr)
     m_LightKit->Delete();
 
   if (m_VtkRenderer != nullptr)
   {
     m_CameraController = nullptr;
 
     m_VtkRenderer->Delete();
 
     m_VtkRenderer = nullptr;
   }
   else
     m_CameraController = nullptr;
 
   if (m_WorldPointPicker != nullptr)
     m_WorldPointPicker->Delete();
   if (m_PointPicker != nullptr)
     m_PointPicker->Delete();
   if (m_CellPicker != nullptr)
     m_CellPicker->Delete();
   if (m_TextRenderer != nullptr)
     m_TextRenderer->Delete();
 }
 
 void mitk::VtkPropRenderer::SetDataStorage(mitk::DataStorage *storage)
 {
   if (storage == nullptr || storage == m_DataStorage)
     return;
 
   BaseRenderer::SetDataStorage(storage);
 
   static_cast<mitk::PlaneGeometryDataVtkMapper3D *>(m_CurrentWorldPlaneGeometryMapper.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::TimeGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D(nullptr, "includeInBoundingBox");
+  auto geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D(nullptr, "includeInBoundingBox");
 
   if (geometry.IsNull())
     return false;
 
   this->SetWorldTimeGeometry(geometry);
   this->GetVtkRenderer()->ResetCamera();
   this->GetCameraController()->Fit();
   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
   for (auto it = m_MappersMap.cbegin(); it != m_MappersMap.cend(); it++)
   {
     Mapper *mapper = (*it).second;
     mapper->MitkRender(this, type);
   }
 
   // Render text
   if (type == VtkPropRenderer::Overlay)
   {
     if (m_TextCollection.size() > 0)
     {
       m_TextRenderer->SetViewport(this->GetVtkRenderer()->GetViewport());
       for (auto 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 < this->GetCurrentWorldPlaneGeometry()->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)
   {
     const DataNode::Pointer node = it->Value();
     if (node.IsNull())
       continue;
     const 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++;
   }
 }
 
 void mitk::VtkPropRenderer::Update(mitk::DataNode *datatreenode)
 {
   if (datatreenode != nullptr)
   {
     mitk::Mapper::Pointer mapper = datatreenode->GetMapper(m_MapperID);
     if (mapper.IsNotNull())
     {
       if (GetCurrentWorldPlaneGeometry()->IsValid())
       {
         mapper->Update(this);
         {
           auto *vtkmapper = dynamic_cast<VtkMapper *>(mapper.GetPointer());
           if (vtkmapper != nullptr)
           {
             vtkmapper->UpdateVtkTransform(this);
           }
         }
       }
     }
   }
 }
 
 void mitk::VtkPropRenderer::Update()
 {
   if (m_DataStorage.IsNull())
     return;
 
   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);
 
   vtkCallbackCommand *renderCallbackCommand = vtkCallbackCommand::New();
   renderCallbackCommand->SetCallback(VtkPropRenderer::RenderingCallback);
   renderWindow->GetInteractor()->AddObserver(vtkCommand::RenderEvent, renderCallbackCommand);
   renderCallbackCommand->Delete();
 
   if (renderWindow == nullptr)
   {
     m_InitNeeded = false;
     m_ResizeNeeded = false;
     return;
   }
 
   m_InitNeeded = true;
   m_ResizeNeeded = true;
 
   m_LastUpdateTime = 0;
 }
 
 void mitk::VtkPropRenderer::RenderingCallback(vtkObject *caller, unsigned long, void *, void *)
 {
   auto *renderWindowInteractor = dynamic_cast<vtkRenderWindowInteractor *>(caller);
   if (!renderWindowInteractor)
     return;
   mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderWindowInteractor->GetRenderWindow());
   if (renderer)
     renderer->RequestUpdate();
 }
 
 /*!
 \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 != nullptr)
   {
     int w = vtkObject::GetGlobalWarningDisplay();
     vtkObject::GlobalWarningDisplayOff();
     m_VtkRenderer->ResetCamera();
     vtkObject::SetGlobalWarningDisplay(w);
   }
   this->GetCameraController()->Fit();
 }
 
 int mitk::VtkPropRenderer::WriteSimpleText(
   std::string text, double posX, double posY, double color1, double color2, double color3, float opacity)
 {
   this->GetVtkRenderer()->ViewToDisplay();
   if (!text.empty())
   {
     Point2D p;
     vtkTextActor *textActor = vtkTextActor::New();
 
     textActor->SetDisplayPosition(posX, posY);
     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;
   }
 }
 
 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 != nullptr)
     m_RenderWindow->MakeCurrent();
 }
 
 void mitk::VtkPropRenderer::PickWorldPoint(const mitk::Point2D &displayPoint, mitk::Point3D &worldPoint) const
 {
   if (this->GetRenderWindow()->GetNeverRendered() != 0)
     return; // somebody called picking before we ever rendered; cannot have enough information yet
 
   switch (m_PickingMode)
   {
     case (WorldPointPicking):
     {
       m_WorldPointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
       vtk2itk(m_WorldPointPicker->GetPickPosition(), worldPoint);
       break;
     }
     case (PointPicking):
     {
       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;
     }
   }
   // todo: is this picking in 2D renderwindows?
   //    Superclass::PickWorldPoint(displayPoint, worldPoint);
 }
 
 mitk::DataNode *mitk::VtkPropRenderer::PickObject(const Point2D &displayPosition, Point3D &worldPosition) const
 {
   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)
   {
     const DataNode *node = it->Value();
     if (node == nullptr)
       continue;
 
     bool pickable = false;
     node->GetBoolProperty("pickable", pickable);
     if (!pickable)
       continue;
 
     auto *mapper = dynamic_cast<VtkMapper *>(node->GetMapper(m_MapperID));
     if (mapper == nullptr)
       continue;
 
     vtkProp *prop = mapper->GetVtkProp((mitk::BaseRenderer *)this);
     if (prop == nullptr)
       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 == nullptr)
   {
     return nullptr;
   }
 
   // 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 == nullptr)
       continue;
 
     auto *vtkmapper = dynamic_cast<VtkMapper *>(mapper);
 
     if (vtkmapper)
     {
       // if vtk-based, then ...
       if (vtkmapper->HasVtkProp(prop, const_cast<mitk::VtkPropRenderer *>(this)))
       {
         return node;
       }
     }
   }
   return nullptr;
 }
 // todo: is this 2D renderwindow picking?
 //    return Superclass::PickObject( displayPosition, worldPosition );
 
 vtkTextProperty *mitk::VtkPropRenderer::GetTextLabelProperty(int text_id)
 {
   return this->m_TextCollection[text_id]->GetTextProperty();
 }
 
 void mitk::VtkPropRenderer::InitPathTraversal()
 {
   if (m_DataStorage.IsNotNull())
   {
     this->UpdatePaths();
     this->m_Paths->InitTraversal();
   }
 }
 
 void mitk::VtkPropRenderer::UpdatePaths()
 {
   if (m_DataStorage.IsNull())
   {
     return;
   }
 
   if (GetMTime() > m_PathTime || (m_Paths != nullptr && m_Paths->GetMTime() > m_PathTime))
   {
     // Create the list to hold all the paths
     m_Paths = vtkSmartPointer<vtkAssemblyPaths>::New();
 
     DataStorage::SetOfObjects::ConstPointer objects = m_DataStorage->GetAll();
     for (auto iter = objects->begin(); iter != objects->end(); ++iter)
     {
       vtkSmartPointer<vtkAssemblyPath> onePath = vtkSmartPointer<vtkAssemblyPath>::New();
       Mapper *mapper = (*iter)->GetMapper(BaseRenderer::Standard3D);
       if (mapper)
       {
         auto *vtkmapper = dynamic_cast<VtkMapper *>(mapper);
         {
           vtkProp *prop = vtkmapper->GetVtkProp(this);
           if (prop && prop->GetVisibility())
           {
             // add to assembly path
             onePath->AddNode(prop, prop->GetMatrix());
             m_Paths->AddItem(onePath);
           }
         }
       }
     }
 
     m_PathTime.Modified();
   }
 }
 
 int mitk::VtkPropRenderer::GetNumberOfPaths()
 {
   UpdatePaths();
   return m_Paths->GetNumberOfItems();
 }
 
 vtkAssemblyPath *mitk::VtkPropRenderer::GetNextPath()
 {
   return m_Paths ? m_Paths->GetNextItem() : nullptr;
 }
 
 void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow * /*renWin*/)
 {
   if (m_DataStorage.IsNull())
     return;
 
   DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
   for (auto iter = allObjects->begin(); iter != allObjects->end(); ++iter)
   {
     DataNode::Pointer node = *iter;
     if (node.IsNull())
       continue;
 
     Mapper *mapper = node->GetMapper(m_MapperID);
 
     if (mapper)
     {
       auto *vtkmapper = dynamic_cast<VtkMapper *>(mapper);
 
       if (vtkmapper)
         vtkmapper->ReleaseGraphicsResources(this);
     }
   }
 }
 
 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();
       }
     }
   }
   else
   {
     if (didCount)
     {
       didCount = false;
       glWorkAroundGlobalCount--;
       if (glWorkAroundGlobalCount == 1)
       {
         MITK_INFO << "Single 3D Renderwindow active...: turning Immediate Rendering OFF for legacy mappers";
         //        vtkMapper::GlobalImmediateModeRenderingOff();
       }
     }
   }
 }
 
 //### 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.
   }
   GetCameraController()->AdjustCameraToPlane();
 }
 
 bool mitk::VtkPropRenderer::Initialize2DvtkCamera()
 {
   if (this->GetMapperID() == Standard3D)
   {
     // activate parallel projection for 2D
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(false);
     vtkSmartPointer<vtkInteractorStyleTrackballCamera> style =
       vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
     this->GetRenderWindow()->GetInteractor()->EnableRenderOff();
     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();
 
     vtkSmartPointer<mitkVtkInteractorStyle> style = vtkSmartPointer<mitkVtkInteractorStyle>::New();
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
     this->GetRenderWindow()->GetInteractor()->EnableRenderOff();
     m_CameraInitializedForMapperID = Standard2D;
   }
   return true;
 }
diff --git a/Modules/Core/test/mitkDataStorageTest.cpp b/Modules/Core/test/mitkDataStorageTest.cpp
index 5f3970b321..a76907f313 100644
--- a/Modules/Core/test/mitkDataStorageTest.cpp
+++ b/Modules/Core/test/mitkDataStorageTest.cpp
@@ -1,878 +1,878 @@
 /*===================================================================
 
 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 <algorithm>
 #include <fstream>
 
 #include "mitkColorProperty.h"
 #include "mitkDataNode.h"
 #include "mitkGroupTagProperty.h"
 #include "mitkImage.h"
 #include "mitkReferenceCountWatcher.h"
 #include "mitkStringProperty.h"
 #include "mitkSurface.h"
 
 #include "mitkDataStorage.h"
 #include "mitkIOUtil.h"
 #include "mitkMessage.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateData.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateDimension.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkNodePredicateSource.h"
 #include "mitkStandaloneDataStorage.h"
 //#include "mitkPicFileReader.h"
 #include "mitkTestingMacros.h"
 
 void TestDataStorage(mitk::DataStorage *ds, std::string filename);
 
 namespace mitk
 {
   class TestStandaloneDataStorage : public StandaloneDataStorage
   {
   public:
     mitkClassMacro(TestStandaloneDataStorage, mitk::DataStorage);
     itkFactorylessNewMacro(Self)
       itkCloneMacro(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(nullptr), m_NodeRemoved(nullptr) {}
   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(nullptr), 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 = nullptr;
   }
 
 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 = nullptr;
 
   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 != nullptr, "DataStorage valid?");
 
   // Take the ItkImageFile Reader for the .nrrd data format.
   // (was previously pic which is now deprecated format)
   mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(filename);
 
   // 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 nullptr data */
     {
       mitk::NodePredicateData::Pointer predicate(mitk::NodePredicateData::New(nullptr));
       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 nullptr 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, nullptr, 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, nullptr, 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, nullptr, 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, nullptr, 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, nullptr, 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, nullptr, 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,
         nullptr,
         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") == nullptr,
                         "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") == nullptr,
                         "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") == nullptr,
                         "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) == nullptr,
                         "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) == nullptr,
                         "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) == nullptr, "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") == nullptr) && (refCountbeforeDS == watcher->GetReferenceCount()),
                           "Checking removal of a node without relations");
       extra = nullptr;
     }
 
     /* 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") == nullptr) && (refCountbeforeDS == watcher->GetReferenceCount()) &&
                             (ds->GetDerivations(n1)->Size() == 1),
                           "Checking removal of a node with a parent");
       extra = nullptr;
     }
 
     /* 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") == nullptr) && (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 = nullptr;
     }
 
     /* 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") == nullptr) && (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 = nullptr;
     }
 
     /* 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") == nullptr) && (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 = nullptr;
     }
   }
   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 = nullptr;
     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") == nullptr) // d1y should be nullptr now
                           &&
                           (ds->GetNamedNode("d2y") == nullptr) // d2y should be nullptr 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") == nullptr), "Checking removal of a parent node");
     extra = nullptr;
   }
 
   /* 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 = nullptr;
     listener.m_NodeRemoved = nullptr;
     ds->Add(extra);
     ds->Remove(extra);
     MITK_TEST_CONDITION((listener.m_NodeRemoved == nullptr) && (listener.m_NodeAdded == nullptr), "Checking RemoveListener");
 
     std::cout << "Pointer handling after event handling: " << std::flush;
     extra = nullptr; // 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::TimeGeometry::Pointer geometry = ds->ComputeBoundingGeometry3D();
+  auto geometry = ds->ComputeBoundingGeometry3D();
   MITK_TEST_CONDITION(geometry->CountTimeSteps() == 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->CountTimeSteps(); i++)
   {
     mitk::BaseGeometry::Pointer subGeometry = geometry->GetGeometryForTimeStep(i);
     mitk::TimeBounds bounds = geometry->GetTimeBounds(i);
     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->CountTimeSteps() == 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->CountTimeSteps(); i++)
   {
     mitk::BaseGeometry::Pointer subGeometry = geometry->GetGeometryForTimeStep(i);
     mitk::TimeBounds bounds = geometry->GetTimeBounds(i);
     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 = nullptr;                             // 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/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
index 63df9a913e..c149b2d814 100644
--- a/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
+++ b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
@@ -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.
 
 ===================================================================*/
 
 #include "mitkRenderWindowViewDirectionController.h"
 
 // mitk
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 
 mitk::RenderWindowViewDirectionController::RenderWindowViewDirectionController()
   : m_DataStorage(nullptr)
 {
   // nothing here
 }
 
 void mitk::RenderWindowViewDirectionController::SetDataStorage(DataStorage::Pointer dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     // set the new data storage
     m_DataStorage = dataStorage;
   }
 }
 
 void mitk::RenderWindowViewDirectionController::SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer)
 {
   if (m_ControlledRenderer != controlledRenderer)
   {
     // set the new set of controlled renderer
     m_ControlledRenderer = controlledRenderer;
   }
 }
 
 void mitk::RenderWindowViewDirectionController::SetViewDirectionOfRenderer(const std::string &viewDirection, BaseRenderer* renderer /*=nullptr*/)
 {
   if (nullptr == renderer)
   {
 
     // set visibility of data node in all controlled renderer
     for (auto& renderer : m_ControlledRenderer)
     {
       if (renderer.IsNotNull())
       {
         //SetViewDirectionOfRenderer(viewDirection, renderer);
       }
     }
   }
   else
   {
     mitk::SliceNavigationController* sliceNavigationController = renderer->GetSliceNavigationController();
     if ("axial" == viewDirection)
     {
       sliceNavigationController->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     }
     else if ("coronal" == viewDirection)
     {
       sliceNavigationController->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
     }
     else if ("sagittal" == viewDirection)
     {
       sliceNavigationController->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
     }
 
     // initialize the views to the bounding geometry
     InitializeViewByBoundingObjects(renderer);
   }
 }
 
 void mitk::RenderWindowViewDirectionController::InitializeViewByBoundingObjects(const BaseRenderer* renderer)
 {
   if (nullptr == m_DataStorage || nullptr == renderer)
   {
     return;
   }
 
   // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateProperty::Pointer includeInBoundingBox = mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false));
   mitk::NodePredicateNot::Pointer notIncludeInBoundingBox = mitk::NodePredicateNot::New(includeInBoundingBox);
 
   // get all non-helper objects
   mitk::NodePredicateProperty::Pointer helperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer notAHelperObject = mitk::NodePredicateNot::New(helperObject);
 
   // get all nodes that have a fixed layer for the given renderer
   mitk::NodePredicateProperty::Pointer fixedLayer = mitk::NodePredicateProperty::New("fixedLayer", mitk::BoolProperty::New(true), renderer);
 
   // combine node predicates
   mitk::NodePredicateAnd::Pointer combinedNodePredicate = mitk::NodePredicateAnd::New(notIncludeInBoundingBox, notAHelperObject, fixedLayer);
   mitk::DataStorage::SetOfObjects::ConstPointer filteredDataNodes = m_DataStorage->GetSubset(combinedNodePredicate);
 
   // calculate bounding geometry of these nodes
-  mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(filteredDataNodes, "visible", renderer);
+  auto bounds = m_DataStorage->ComputeBoundingGeometry3D(filteredDataNodes, "visible", renderer);
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeView(renderer->GetRenderWindow(), bounds);
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
index 00e1a16034..5504695e80 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
@@ -1,557 +1,557 @@
 /*===================================================================
 
 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 <berryIPreferences.h>
 
 #include <QWidget>
 
 #include <mitkColorProperty.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkDataStorageEditorInput.h>
 #include <mitkIDataStorageService.h>
 
 #include <QmitkMouseModeSwitcher.h>
 #include <QmitkStdMultiWidget.h>
 
 class QmitkStdMultiWidgetEditorPrivate
 {
 public:
 
   QmitkStdMultiWidgetEditorPrivate();
   ~QmitkStdMultiWidgetEditorPrivate();
 
   QmitkStdMultiWidget* m_StdMultiWidget;
   QmitkMouseModeSwitcher* m_MouseModeToolbar;
   /**
   * @brief Members for the MultiWidget decorations.
   */
   QString m_WidgetBackgroundColor1[4];
   QString m_WidgetBackgroundColor2[4];
   QString m_WidgetDecorationColor[4];
   QString m_WidgetAnnotation[4];
   bool m_MenuWidgetsEnabled;
   QScopedPointer<berry::IPartListener> m_PartListener;
 
   QHash<QString, QmitkRenderWindow*> m_RenderWindows;
 
 };
 
 struct QmitkStdMultiWidgetPartListener : public berry::IPartListener
 {
   QmitkStdMultiWidgetPartListener(QmitkStdMultiWidgetEditorPrivate* dd)
     : d(dd)
   {}
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::CLOSED | Events::HIDDEN | Events::VISIBLE | Events::OPENED;
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     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(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         stdMultiWidgetEditor->RequestActivateMenuWidget(true);
       }
     }
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef) override
   {
     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(nullptr), m_MouseModeToolbar(nullptr)
   , m_MenuWidgetsEnabled(false)
   , m_PartListener(new QmitkStdMultiWidgetPartListener(this))
 {}
 
 QmitkStdMultiWidgetEditorPrivate::~QmitkStdMultiWidgetEditorPrivate()
 {
 }
 
 const QString QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget";
 
 QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor()
   : d(new QmitkStdMultiWidgetEditorPrivate)
 {
 }
 
 QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor()
 {
   this->GetSite()->GetPage()->RemovePartListener(d->m_PartListener.data());
 }
 
 QmitkStdMultiWidget* QmitkStdMultiWidgetEditor::GetStdMultiWidget()
 {
   return d->m_StdMultiWidget;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   if (d->m_StdMultiWidget) return d->m_StdMultiWidget->GetRenderWindow1();
   return nullptr;
 }
 
 QHash<QString, QmitkRenderWindow *> QmitkStdMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   return d->m_RenderWindows;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetQmitkRenderWindow(const QString &id) const
 {
   if (d->m_RenderWindows.contains(id))
     return d->m_RenderWindows[id];
 
   return nullptr;
 }
 
 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();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_CORNER_ANNOTATION))
   {
     enable ? d->m_StdMultiWidget->SetCornerAnnotationVisibility(true)
            : d->m_StdMultiWidget->SetCornerAnnotationVisibility(false);
   }
 }
 
 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();
   }
   else if (decoration == DECORATION_CORNER_ANNOTATION)
   {
     return d->m_StdMultiWidget->IsCornerAnnotationVisible();
   }
 
   return false;
 }
 
 QStringList QmitkStdMultiWidgetEditor::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_BORDER << DECORATION_LOGO << DECORATION_MENU << DECORATION_BACKGROUND << DECORATION_CORNER_ANNOTATION;
   return decorations;
 }
 
 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, nullptr);
     return visible;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (d->m_StdMultiWidget == nullptr)
   {
     QHBoxLayout* layout = new QHBoxLayout(parent);
     layout->setContentsMargins(0,0,0,0);
 
     if (d->m_MouseModeToolbar == nullptr)
     {
       d->m_MouseModeToolbar = new QmitkMouseModeSwitcher(parent); // delete by Qt via parent
       layout->addWidget(d->m_MouseModeToolbar);
     }
 
     berry::IPreferences::Pointer prefs = this->GetPreferences();
 
     mitk::BaseRenderer::RenderingMode::Type renderingMode = static_cast<mitk::BaseRenderer::RenderingMode::Type>(prefs->GetInt( "Rendering Mode" , 0 ));
 
     d->m_StdMultiWidget = new QmitkStdMultiWidget(parent,nullptr,nullptr,renderingMode);
     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() );
 
     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::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
+    auto 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.data());
 
     berry::IBerryPreferences* berryprefs = dynamic_cast<berry::IBerryPreferences*>(prefs.GetPointer());
     InitializePreferences(berryprefs);
     this->OnPreferencesChanged(berryprefs);
 
     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.
 
   //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->SetDepartmentLogo(qPrintable(":/org.mitk.gui.qt.stdmultiwidgeteditor/defaultWatermark.png"));
   d->m_StdMultiWidget->EnableDepartmentLogo();
 
   const berry::IPreferences* currentNode = prefs;
 
   while(currentNode)
   {
     bool logoFound = false;
     foreach (const QString& key, currentNode->Keys())
     {
       if( key == "DepartmentLogo")
       {
         QString departmentLogoLocation = currentNode->Get("DepartmentLogo", "");
 
         if (departmentLogoLocation.isEmpty())
         {
           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->SetDepartmentLogo(qPrintable(departmentLogoLocation));
           d->m_StdMultiWidget->EnableDepartmentLogo();
         }
         logoFound = true;
         break;
       }
     }
 
     if (logoFound) break;
     currentNode = currentNode->Parent().GetPointer();
   }
 
   //Update internal members
   this->FillMembersWithCurrentDecorations();
   this->GetPreferenceDecorations(prefs);
   //Now the members can be used to modify the stdmultiwidget
   mitk::Color upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[0]);
   mitk::Color lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[0]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 0);
   upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[1]);
   lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[1]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 1);
   upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[2]);
   lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[2]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 2);
   upper = HexColorToMitkColor(d->m_WidgetBackgroundColor1[3]);
   lower = HexColorToMitkColor(d->m_WidgetBackgroundColor2[3]);
   d->m_StdMultiWidget->SetGradientBackgroundColorForRenderWindow(upper, lower, 3);
   d->m_StdMultiWidget->EnableGradientBackground();
 
   // preferences for renderWindows
   mitk::Color colorDecorationWidget1 = HexColorToMitkColor(d->m_WidgetDecorationColor[0]);
   mitk::Color colorDecorationWidget2 = HexColorToMitkColor(d->m_WidgetDecorationColor[1]);
   mitk::Color colorDecorationWidget3 = HexColorToMitkColor(d->m_WidgetDecorationColor[2]);
   mitk::Color colorDecorationWidget4 = HexColorToMitkColor(d->m_WidgetDecorationColor[3]);
   d->m_StdMultiWidget->SetDecorationColor(0, colorDecorationWidget1);
   d->m_StdMultiWidget->SetDecorationColor(1, colorDecorationWidget2);
   d->m_StdMultiWidget->SetDecorationColor(2, colorDecorationWidget3);
   d->m_StdMultiWidget->SetDecorationColor(3, colorDecorationWidget4);
 
   for(unsigned int i = 0; i < 4; ++i)
   {
     d->m_StdMultiWidget->SetDecorationProperties(d->m_WidgetAnnotation[i].toStdString(),
                                              HexColorToMitkColor(d->m_WidgetDecorationColor[i]), i);
   }
   //The crosshair gap
   int crosshairgapsize = prefs->GetInt("crosshair gap size", 32);
   d->m_StdMultiWidget->GetWidgetPlane1()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
   d->m_StdMultiWidget->GetWidgetPlane2()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
   d->m_StdMultiWidget->GetWidgetPlane3()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize);
 
   //refresh colors of rectangles
   d->m_StdMultiWidget->EnableColoredRectangles();
 
   // Set preferences respecting zooming and panning
   bool constrainedZooming = prefs->GetBool("Use constrained zooming and panning", true);
 
   mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 
   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 );
 }
 
 mitk::Color QmitkStdMultiWidgetEditor::HexColorToMitkColor(const QString& widgetColorInHex)
 {
   QColor qColor(widgetColorInHex);
   mitk::Color returnColor;
   float colorMax = 255.0f;
   if (widgetColorInHex.isEmpty()) // default value
   {
     returnColor[0] = 1.0;
     returnColor[1] = 1.0;
     returnColor[2] = 1.0;
     MITK_ERROR << "Using default color for unknown widget " << qPrintable(widgetColorInHex);
   }
   else
   {
     returnColor[0] = qColor.red() / colorMax;
     returnColor[1] = qColor.green() / colorMax;
     returnColor[2] = qColor.blue() / colorMax;
   }
   return returnColor;
 }
 
 QString QmitkStdMultiWidgetEditor::MitkColorToHex(const mitk::Color& color)
 {
   QColor returnColor;
   float colorMax = 255.0f;
   returnColor.setRed(static_cast<int>(color[0]* colorMax + 0.5));
   returnColor.setGreen(static_cast<int>(color[1]* colorMax + 0.5));
   returnColor.setBlue(static_cast<int>(color[2]* colorMax + 0.5));
   return returnColor.name();
 }
 
 void QmitkStdMultiWidgetEditor::FillMembersWithCurrentDecorations()
 {
   //fill members with current values (or default values) from the std multi widget
   for(unsigned int i = 0; i < 4; ++i)
   {
     d->m_WidgetDecorationColor[i] = MitkColorToHex(d->m_StdMultiWidget->GetDecorationColor(i));
     d->m_WidgetBackgroundColor1[i] = MitkColorToHex(d->m_StdMultiWidget->GetGradientColors(i).first);
     d->m_WidgetBackgroundColor2[i] = MitkColorToHex(d->m_StdMultiWidget->GetGradientColors(i).second);
     d->m_WidgetAnnotation[i] = QString::fromStdString(d->m_StdMultiWidget->GetCornerAnnotationText(i));
   }
 }
 
 void QmitkStdMultiWidgetEditor::GetPreferenceDecorations(const berry::IBerryPreferences * preferences)
 {
   //overwrite members with values from the preferences, if they the prefrence is defined
   d->m_WidgetBackgroundColor1[0] = preferences->Get("widget1 first background color", d->m_WidgetBackgroundColor1[0]);
   d->m_WidgetBackgroundColor2[0] = preferences->Get("widget1 second background color", d->m_WidgetBackgroundColor2[0]);
   d->m_WidgetBackgroundColor1[1] = preferences->Get("widget2 first background color", d->m_WidgetBackgroundColor1[1]);
   d->m_WidgetBackgroundColor2[1] = preferences->Get("widget2 second background color", d->m_WidgetBackgroundColor2[1]);
   d->m_WidgetBackgroundColor1[2] = preferences->Get("widget3 first background color", d->m_WidgetBackgroundColor1[2]);
   d->m_WidgetBackgroundColor2[2] = preferences->Get("widget3 second background color", d->m_WidgetBackgroundColor2[2]);
   d->m_WidgetBackgroundColor1[3] = preferences->Get("widget4 first background color", d->m_WidgetBackgroundColor1[3]);
   d->m_WidgetBackgroundColor2[3] = preferences->Get("widget4 second background color", d->m_WidgetBackgroundColor2[3]);
 
   d->m_WidgetDecorationColor[0] = preferences->Get("widget1 decoration color", d->m_WidgetDecorationColor[0]);
   d->m_WidgetDecorationColor[1] = preferences->Get("widget2 decoration color", d->m_WidgetDecorationColor[1]);
   d->m_WidgetDecorationColor[2] = preferences->Get("widget3 decoration color", d->m_WidgetDecorationColor[2]);
   d->m_WidgetDecorationColor[3] = preferences->Get("widget4 decoration color", d->m_WidgetDecorationColor[3]);
 
   d->m_WidgetAnnotation[0] = preferences->Get("widget1 corner annotation", d->m_WidgetAnnotation[0]);
   d->m_WidgetAnnotation[1] = preferences->Get("widget2 corner annotation", d->m_WidgetAnnotation[1]);
   d->m_WidgetAnnotation[2] = preferences->Get("widget3 corner annotation", d->m_WidgetAnnotation[2]);
   d->m_WidgetAnnotation[3] = preferences->Get("widget4 corner annotation", d->m_WidgetAnnotation[3]);
 }
 
 void QmitkStdMultiWidgetEditor::InitializePreferences(berry::IBerryPreferences * preferences)
 {
   this->FillMembersWithCurrentDecorations(); //fill members
   this->GetPreferenceDecorations(preferences); //overwrite if preferences are defined
 
   //create new preferences
   preferences->Put("widget1 corner annotation", d->m_WidgetAnnotation[0]);
   preferences->Put("widget2 corner annotation", d->m_WidgetAnnotation[1]);
   preferences->Put("widget3 corner annotation", d->m_WidgetAnnotation[2]);
   preferences->Put("widget4 corner annotation", d->m_WidgetAnnotation[3]);
 
   preferences->Put("widget1 decoration color", d->m_WidgetDecorationColor[0]);
   preferences->Put("widget2 decoration color", d->m_WidgetDecorationColor[1]);
   preferences->Put("widget3 decoration color", d->m_WidgetDecorationColor[2]);
   preferences->Put("widget4 decoration color", d->m_WidgetDecorationColor[3]);
 
   preferences->Put("widget1 first background color", d->m_WidgetBackgroundColor1[0]);
   preferences->Put("widget2 first background color", d->m_WidgetBackgroundColor1[1]);
   preferences->Put("widget3 first background color", d->m_WidgetBackgroundColor1[2]);
   preferences->Put("widget4 first background color", d->m_WidgetBackgroundColor1[3]);
   preferences->Put("widget1 second background color", d->m_WidgetBackgroundColor2[0]);
   preferences->Put("widget2 second background color", d->m_WidgetBackgroundColor2[1]);
   preferences->Put("widget3 second background color", d->m_WidgetBackgroundColor2[2]);
   preferences->Put("widget4 second background color", d->m_WidgetBackgroundColor2[3]);
 }
 
 void QmitkStdMultiWidgetEditor::SetFocus()
 {
   if (d->m_StdMultiWidget != nullptr)
     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);
     }
   }
 }