diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h
index 2c4989f8ab..6e30a38584 100644
--- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h
+++ b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h
@@ -1,71 +1,71 @@
 /*===================================================================
 
 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 MITKRENDERWINDOWLAYERUTILITIES_H
 #define MITKRENDERWINDOWLAYERUTILITIES_H
 
 // render window manager module
 #include "MitkRenderWindowManagerExports.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
 #include <mitkDataStorage.h>
 #include <mitkNodePredicateAnd.h>
 
 /**
 * @brief Render window layer helper functions to retrieve the currently valid layer stack
 */
 namespace mitk
 {
   namespace RenderWindowLayerUtilities
   {
-    typedef std::vector<BaseRenderer::Pointer> RendererVector;
+    typedef std::vector<BaseRenderer*> RendererVector;
     typedef std::map<int, DataNode::Pointer, std::greater<int>> LayerStack;
 
     /**
     * The base data node of a renderer is supposed to be on layer 0 (zero), which should be the lowest layer in a render window.
     */
     const int BASE_LAYER_INDEX = 0;
     /**
     * The top layer index, denoting that no valid (positive) layer index is given and therefore the index should be resolved into the topmost layer index.
     */
     const int TOP_LAYER_INDEX = -1;
 
     /**
     * @brief Return the stack of layers of the given renderer as std::map<int, DataNode::Pointer>, which guarantees ordering of the layers.
     *        Stacked layers are only included if they have their "fixedLayer" property set to true and their "layer" property set.
     *
     *        If "renderer"      = nullptr: a layer stack won't be created and an empty "LayerStack" will be returned.
     *        If "withBaseNode"  = true: include the base node in the layer stack, if existing.
     *        If "withBaseNode"  = false: exclude the base node from the layer stack.
     *
     * @param dataStorage    Pointer to a data storage instance whose data nodes should be checked and possibly be included.
     * @param renderer       Pointer to the renderer instance for which the layer stack should be generated.
     * @param withBaseNode   Boolean to decide whether the base node should be included in or excluded from the layer stack.
     */
     MITKRENDERWINDOWMANAGER_EXPORT LayerStack GetLayerStack(const DataStorage* dataStorage, const BaseRenderer* renderer, bool withBaseNode);
     /**
     * @brief Helper function to get a node predicate that can be used to filter render window specific data nodes.
     *
     *        The data nodes must not be 'helper objects'. The must have set a 'fixed layer' property for the given renderer.
     */
     MITKRENDERWINDOWMANAGER_EXPORT NodePredicateAnd::Pointer GetRenderWindowPredicate(const BaseRenderer* renderer);
 
   } // namespace RenderWindowLayerUtilities
 } // namespace mitk
 
 #endif // MITKRENDERWINDOWLAYERUTILITIES_H
diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h b/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h
index c158658eef..9280a6df77 100644
--- a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h
+++ b/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h
@@ -1,86 +1,86 @@
 /*===================================================================
 
 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 MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H
 #define MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H
 
 // render window manager module
 #include "MitkRenderWindowManagerExports.h"
 #include "mitkRenderWindowLayerUtilities.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataStorage.h>
 
 namespace mitk
 {
   /**
   * The RenderWindowViewDirectionController is used to manipulate the 'sliceNavigationController' of a given base renderer.
   * The 'sliceNavigationController' is used to set the view direction / camera perspective of a base renderer.
   * The view direction can changed to 'mitk::SliceNavigationController::Axial', 'mitk::SliceNavigationController::Frontal'
   * or 'mitk::SliceNavigationController::Sagittal'.
   *
   * Functions with 'mitk::BaseRenderer* renderer' have 'nullptr' as their default argument. Using the nullptr
   * these functions operate on all base renderer. Giving a specific base renderer will modify the view direction only for the given renderer.
   */
   class MITKRENDERWINDOWMANAGER_EXPORT RenderWindowViewDirectionController
   {
   public:
     
     using ViewDirection = mitk::SliceNavigationController::ViewDirection;
 
     RenderWindowViewDirectionController();
     /**
     * @brief Set the data storage on which to work.
     */
     void SetDataStorage(DataStorage::Pointer dataStorage);
     /**
     * @brief Set the controlled base renderer.
     */
     void SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer);
 
     // wrapper functions to modify the view direction
     /**
     * @brief Set the view direction for the given renderer (nullptr = all renderer)
     * @param viewDirection  The view direction that should be used for this renderer as a string.
     *                       Currently "axial", "coronal" and "sagittal" is supported.
     * @param renderer       Pointer to the renderer instance for which the view direction should be changed.
     *                       If it is a nullptr (default) all controlled renderer will be affected.
     */
-    void SetViewDirectionOfRenderer(const std::string &viewDirection, BaseRenderer* renderer = nullptr);
+    void SetViewDirectionOfRenderer(const std::string& viewDirection, BaseRenderer* renderer = nullptr);
     /**
     * @brief Set the view direction for the given renderer (nullptr = all renderer)
     * @param viewDirection  The view direction that should be used for this renderer.
     * @param renderer       Pointer to the renderer instance for which the view direction should be changed.
     *                       If it is a nullptr (default) nothing happens.
     */
     void SetViewDirectionOfRenderer(ViewDirection viewDirection, BaseRenderer* renderer = nullptr);
     /**
     * @brief Reinitialize the given renderer with the currently visible nodes.
     * @param renderer       Pointer to the renderer instance for which the view direction should be changed.
     *                       If it is a nullptr (default) all controlled renderer will be affected.
     */
     void InitializeViewByBoundingObjects(const BaseRenderer* renderer);
 
   private:
 
     DataStorage::Pointer m_DataStorage;
     RenderWindowLayerUtilities::RendererVector m_ControlledRenderer;
   };
 
 } // namespace mitk
 
 #endif // MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H
diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp
index 8f01e2ea6c..2ba1043c82 100644
--- a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp
+++ b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp
@@ -1,575 +1,575 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // render window manager module
 #include "mitkRenderWindowLayerController.h"
 
 mitk::RenderWindowLayerController::RenderWindowLayerController()
   : m_DataStorage(nullptr)
 {
   // nothing here
 }
 
 void mitk::RenderWindowLayerController::SetDataStorage(DataStorage::Pointer dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     // set the new data storage
     m_DataStorage = dataStorage;
   }
 }
 
 void mitk::RenderWindowLayerController::SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer)
 {
   if (m_ControlledRenderer != controlledRenderer)
   {
     // set the new set of controlled renderer
     m_ControlledRenderer = controlledRenderer;
   }
 }
 
 void mitk::RenderWindowLayerController::SetBaseDataNode(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (nullptr == renderer)
   {
     // set the data node as base data node in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         SetBaseDataNode(dataNode, renderer);
       }
     }
   }
   else
   {
     // get the layer stack with the base data node of the current renderer
     RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true);
     if (!stackedLayers.empty())
     {
       // see if base layer exists
       RenderWindowLayerUtilities::LayerStack::iterator layerStackIterator = stackedLayers.find(RenderWindowLayerUtilities::BASE_LAYER_INDEX);
       if (layerStackIterator != stackedLayers.end())
       {
         // remove the current base data node from the current renderer
         layerStackIterator->second->GetPropertyList(renderer)->DeleteProperty("layer");
         layerStackIterator->second->SetBoolProperty("fixedLayer", false, renderer);
         layerStackIterator->second->SetVisibility(false, renderer);
       }
     }
 
     // "RenderWindowLayerUtilities::BASE_LAYER_INDEX" indicates the base data node --> set as new background
     dataNode->SetIntProperty("layer", RenderWindowLayerUtilities::BASE_LAYER_INDEX, renderer);
     dataNode->SetBoolProperty("fixedLayer", true, renderer);
     dataNode->SetVisibility(true, renderer);
     dataNode->Modified();
     mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
   }
 }
 
 void mitk::RenderWindowLayerController::InsertLayerNode(DataNode* dataNode, int layer /*= RenderWindowLayerUtilities::TOP_LAYER_INDEX*/, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (nullptr == renderer)
   {
     // insert data node in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         InsertLayerNode(dataNode, layer, renderer);
       }
     }
   }
   else
   {
     if (RenderWindowLayerUtilities::BASE_LAYER_INDEX == layer)
     {
       // "RenderWindowLayerUtilities::BASE_LAYER_INDEX" indicates the base data node --> set as new background (overwrite current base node if needed)
       SetBaseDataNode(dataNode, renderer);
     }
     else
     {
       InsertLayerNodeInternal(dataNode, layer, renderer);
     }
   }
 }
 
 void mitk::RenderWindowLayerController::InsertLayerNodeInternal(DataNode* dataNode, int newLayer, const BaseRenderer* renderer /*= nullptr*/)
 {
   dataNode->SetBoolProperty("fixedLayer", true, renderer);
   // use visibility of existing renderer or common renderer
   bool visible = false;
   bool visibilityProperty = dataNode->GetVisibility(visible, renderer);
   if (true == visibilityProperty)
   {
     // found a visibility property
     dataNode->SetVisibility(visible, renderer);
   }
 
   // get the layer stack without the base node of the current renderer
   RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false);
   if (stackedLayers.empty())
   {
     // no layer stack for the current renderer
     if (RenderWindowLayerUtilities::TOP_LAYER_INDEX == newLayer)
     {
       // set given layer as first layer above base layer (= 1)
       newLayer = 1;
       // alternatively: no layer stack for the current renderer -> insert as background node
       //SetBaseDataNode(dataNode, renderer);
     }
   }
   else
   {
     if (RenderWindowLayerUtilities::TOP_LAYER_INDEX == newLayer)
     {
       // get the first value (highest int-key -> topmost layer)
       // + 1 indicates inserting the node above the topmost layer
       newLayer = stackedLayers.begin()->first + 1;
     }
     else
     {
       MoveNodeToPosition(dataNode, newLayer, renderer);
       return;
     }
   }
   // update data storage (the "data node model")
   dataNode->SetIntProperty("layer", newLayer, renderer);
   dataNode->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
 }
 
 void mitk::RenderWindowLayerController::RemoveLayerNode(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (nullptr == renderer)
   {
     // remove data node from all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         RemoveLayerNode(dataNode, renderer);
       }
     }
   }
   else
   {
     // "remove" node from the renderer list
     dataNode->GetPropertyList(renderer)->DeleteProperty("layer");
     dataNode->SetBoolProperty("fixedLayer", false, renderer);
     dataNode->SetVisibility(false, renderer);
     dataNode->Modified();
     mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
   }
 }
 
 bool mitk::RenderWindowLayerController::MoveNodeToPosition(DataNode* dataNode, int newLayer, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return false;
   }
 
   if (nullptr == renderer)
   {
     // move data node to position in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         MoveNodeToPosition(dataNode, newLayer, renderer);
         // we don't store/need the returned boolean value
         return false;
       }
     }
   }
   else
   {
     // get the layer stack without the base node of the current renderer
     RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false);
     if (!stackedLayers.empty())
     {
       // get the current layer value of the given data node
       int currentLayer;
       bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer);
       if (wasFound && currentLayer != newLayer)
       {
         // move the given data node to the specified layer
         dataNode->SetIntProperty("layer", newLayer, renderer);
 
         int upperBound;
         int lowerBound;
         int step;
         if (currentLayer < newLayer)
         {
           // move node up
           upperBound = newLayer + 1;
           lowerBound = currentLayer + 1;
           step = -1; // move all other nodes one step down
         }
         else
         {
           upperBound = currentLayer;
           lowerBound = newLayer;
           step = 1; // move all other nodes one step up
         }
 
         // move all other data nodes between the upper and the lower bound
         for (auto& layer : stackedLayers)
         {
           if (layer.second != dataNode && layer.first < upperBound && layer.first >= lowerBound)
           {
             layer.second->SetIntProperty("layer", layer.first + step, renderer);
           }
           // else: current data node is the selected data node or
           // was previously already above the selected data node or
           // was previously already below the new layer position
         }
         dataNode->Modified();
         mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
         return true;
       }
       // else: data node has no layer information or is already at the specified position
     }
     // else: do not work with empty layer stack
   }
   return false;
 }
 
 bool mitk::RenderWindowLayerController::MoveNodeToFront(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return false;
   }
 
   if (nullptr == renderer)
   {
     // move data node to front in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         MoveNodeToFront(dataNode, renderer);
         // we don't store/need the returned boolean value
         return false;
       }
     }
   }
   else
   {
     // get the layer stack without the base node of the current renderer
     RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false);
     if (!stackedLayers.empty())
     {
       // get the first value (highest int-key -> topmost layer)
       int topmostLayer = stackedLayers.begin()->first;
       // get the current layer value of the given data node
       int currentLayer;
       bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer);
       if (wasFound && currentLayer < topmostLayer)
       {
         // move the current data node above the current topmost layer
         dataNode->SetIntProperty("layer", topmostLayer+1, renderer);
         dataNode->Modified();
         mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
         return true;
       }
       // else: data node has no layer information or is already the topmost layer node
     }
     // else: do not work with empty layer stack
   }
   return false;
 }
 
 bool mitk::RenderWindowLayerController::MoveNodeToBack(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return false;
   }
 
   if (nullptr == renderer)
   {
     // move data node to back in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         MoveNodeToBack(dataNode, renderer);
         // we don't store/need the returned boolean value
         return false;
       }
     }
   }
   else
   {
     // get the layer stack without the base node of the current renderer
     RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false);
     if (!stackedLayers.empty())
     {
       // get the last value (lowest int-key)
       // cannot be the base layer as the base node was excluded by the 'GetLayerStack'-function
       int lowermostLayer = stackedLayers.rbegin()->first;
       // get the current layer value of the given data node
       int currentLayer;
       bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer);
       if (wasFound && currentLayer > lowermostLayer)
       {
         // move the current data node to the current lowermost layer
         dataNode->SetIntProperty("layer", lowermostLayer, renderer);
         // move all other data nodes one layer up
         for (auto& layer : stackedLayers)
         {
           if (layer.second != dataNode && layer.first < currentLayer)
           {
             layer.second->SetIntProperty("layer", layer.first + 1, renderer);
           }
           // else: current data node is the selected data node or
           // was previously already above the selected data node
         }
         dataNode->Modified();
         mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
         return true;
       }
       // else: data node has no layer information or is already the lowermost layer node
     }
     // else: do not work with empty layer stack
   }
   return false;
 }
 
 bool mitk::RenderWindowLayerController::MoveNodeUp(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return false;
   }
 
   if (nullptr == renderer)
   {
     // move data node down in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         MoveNodeUp(dataNode, renderer);
         // we don't store/need the returned boolean value
         return false;
       }
     }
   }
   else
   {
     // get the layer stack without the base node of the current renderer
     RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false);
     if (!stackedLayers.empty())
     {
       // get the current layer value of the given data node
       int currentLayer;
       bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer);
       if (wasFound)
       {
         // get the current layer in the map of stacked layers
         RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIterator = stackedLayers.find(currentLayer);
         if (layerStackIterator != stackedLayers.end() && layerStackIterator != stackedLayers.begin())
         {
           // found the element in the map, at different position than 'begin' ->
           // current node is not on the topmost layer and therefore can be moved one layer up
           // swap the layers of the dataNode and the dataNode on the next higher layer (previous map element)
           RenderWindowLayerUtilities::LayerStack::const_iterator prevLayerStackIterator = std::prev(layerStackIterator);
           dataNode->SetIntProperty("layer", prevLayerStackIterator->first, renderer);
           prevLayerStackIterator->second->SetIntProperty("layer", currentLayer, renderer);
           dataNode->Modified();
           mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
           return true;
         }
         // else: layer stack does not contain a layer with the 'currentLayer'data node or
         //       layer is already the topmost layer node
       }
       // else: data node has no layer information
     }
     // else: do not work with empty layer stack
   }
   return false;
 }
 
 bool mitk::RenderWindowLayerController::MoveNodeDown(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return false;
   }
 
   if (nullptr == renderer)
   {
     // move data node up in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         MoveNodeDown(dataNode, renderer);
         // we don't store/need the returned boolean value
         return false;
       }
     }
   }
   else
   {
     // get the layer stack without the base node of the current renderer
     RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false);
     if (!stackedLayers.empty())
     {
       // get the current layer value of the given data node
       int currentLayer;
       bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer);
       if (wasFound)
       {
         // get the current layer in the map of stacked layers
         RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIterator = stackedLayers.find(currentLayer);
         if (layerStackIterator != stackedLayers.end())
         {
           // found the element in the map ...
           RenderWindowLayerUtilities::LayerStack::const_iterator nextLayerStackIterator = std::next(layerStackIterator);
           if (nextLayerStackIterator != stackedLayers.end())
           {
             // ... and found a successor ->
             // current node is not on the lowermost layer and therefore can be moved one layer down
             // swap the layers of the dataNode and the dataNode on the next lower layer (next map element)
             dataNode->SetIntProperty("layer", nextLayerStackIterator->first, renderer);
             nextLayerStackIterator->second->SetIntProperty("layer", currentLayer, renderer);
             dataNode->Modified();
             mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
             return true;
           }
           // else: data node is already the lowermost layer node
         }
         // else: layer stack does not contain a layer with the 'currentLayer'
       }
       // else: data node has no layer information
     }
     // else: do not work with empty layer stack
   }
   return false;
 }
 
 void mitk::RenderWindowLayerController::SetVisibilityOfDataNode(bool visibility, DataNode* dataNode, const BaseRenderer* renderer /*=nullptr*/)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   if (nullptr == renderer)
   {
     // set visibility of data node in all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         SetVisibilityOfDataNode(visibility, dataNode, renderer);
       }
     }
   }
   else
   {
     dataNode->SetVisibility(visibility, renderer);
     dataNode->Modified();
     mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
   }
 }
 
 void mitk::RenderWindowLayerController::HideDataNodeInAllRenderer(const DataNode* dataNode)
 {
   if (nullptr == dataNode)
   {
     return;
   }
 
   for (const auto& renderer : m_ControlledRenderer)
   {
-    if (renderer.IsNotNull())
+    if (nullptr != renderer)
     {
       dataNode->GetPropertyList(renderer)->SetBoolProperty("visible", false);
     }
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::RenderWindowLayerController::ResetRenderer(bool onlyVisibility /*= true*/, const BaseRenderer* renderer /*= nullptr*/)
 {
   if (nullptr == renderer)
   {
     // reset all controlled renderer
     for (const auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         ResetRenderer(onlyVisibility, renderer);
       }
     }
   }
   else
   {
     // get the layer stack with the base node of the current renderer
     RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true);
     if (!stackedLayers.empty())
     {
       for (const auto& layer : stackedLayers)
       {
         int layerLevel;
         layer.second->GetIntProperty("layer", layerLevel, renderer);
         if (RenderWindowLayerUtilities::BASE_LAYER_INDEX == layerLevel)
         {
           // set base data node visibility to true
           layer.second->SetVisibility(true, renderer);
         }
         else
         {
           // set visibility of all other data nodes to false
           layer.second->SetVisibility(false, renderer);
 
           // modify layer node
           if (!onlyVisibility)
           {
             // clear mode: additionally remove layer node from current renderer
             layer.second->GetPropertyList(renderer)->DeleteProperty("layer");
             layer.second->SetBoolProperty("fixedLayer", false, renderer);
           }
         }
         layer.second->Modified();
       }
 
       mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow());
     }
   }
 }
diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
index 1e9a92774d..da4e1cefb9 100644
--- a/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
+++ b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
@@ -1,132 +1,132 @@
 /*===================================================================
 
 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 core
 #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*/)
+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())
+      if (nullptr != renderer)
       {
         SetViewDirectionOfRenderer(viewDirection, renderer);
       }
     }
   }
   else
   {
     mitk::SliceNavigationController* sliceNavigationController = renderer->GetSliceNavigationController();
     if ("axial" == viewDirection)
     {
       sliceNavigationController->SetDefaultViewDirection(ViewDirection::Axial);
     }
     else if ("coronal" == viewDirection)
     {
       sliceNavigationController->SetDefaultViewDirection(ViewDirection::Frontal);
     }
     else if ("sagittal" == viewDirection)
     {
       sliceNavigationController->SetDefaultViewDirection(ViewDirection::Sagittal);
     }
 
     // initialize the views to the bounding geometry
     InitializeViewByBoundingObjects(renderer);
   }
 }
 
 void mitk::RenderWindowViewDirectionController::SetViewDirectionOfRenderer(ViewDirection viewDirection , BaseRenderer* renderer/* =nullptr*/)
 {
   if (nullptr == renderer)
   {
     // set visibility of data node in all controlled renderer
     for (auto& renderer : m_ControlledRenderer)
     {
-      if (renderer.IsNotNull())
+      if (nullptr != renderer)
       {
         SetViewDirectionOfRenderer(viewDirection, renderer);
       }
     }
   }
   else
   {
     mitk::SliceNavigationController* sliceNavigationController = renderer->GetSliceNavigationController();
     sliceNavigationController->SetDefaultViewDirection(viewDirection);
 
     // 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
   auto bounds = m_DataStorage->ComputeBoundingGeometry3D(filteredDataNodes, "visible", renderer);
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeView(renderer->GetRenderWindow(), bounds);
 }
diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
index 8db66a68b5..e1b67d83d0 100644
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp
@@ -1,124 +1,127 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // render window manager plugin
 #include "QmitkRenderWindowManagerView.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
+#include <QmitkRenderWindow.h>
 
 // qt
 #include <QGlobal.h>
 
 const std::string QmitkRenderWindowManagerView::VIEW_ID = "org.mitk.views.renderwindowmanager";
 
 void QmitkRenderWindowManagerView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
+    SetControlledRenderer();
   }
-
-  SetControlledRenderer();
 }
 
 void QmitkRenderWindowManagerView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart == renderWindowPart)
   {
     m_RenderWindowPart = nullptr;
+    SetControlledRenderer();
   }
-
-  SetControlledRenderer();
 }
 
 void QmitkRenderWindowManagerView::RenderWindowPartInputChanged(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart == renderWindowPart)
   {
     SetControlledRenderer();
   }
 }
 
 void QmitkRenderWindowManagerView::SetFocus()
 {
   // nothing here
 }
 
 void QmitkRenderWindowManagerView::CreateQtPartControl(QWidget* parent)
 {
   // create GUI widgets
   m_Controls.setupUi(parent);
 
   // add custom render window manager UI widget to the 'renderWindowManagerTab'
   m_RenderWindowInspector = new QmitkDataStorageRenderWindowInspector(parent);
   m_RenderWindowInspector->SetDataStorage(GetDataStorage());
   m_RenderWindowInspector->setObjectName(QStringLiteral("m_RenderWindowManipulatorWidget"));
   m_Controls.verticalLayout->addWidget(m_RenderWindowInspector);
 
   // data node context menu and menu actions
   m_InspectorView = m_RenderWindowInspector->GetView();
   m_DataNodeContextMenu = new QmitkDataNodeContextMenu(GetSite(), m_InspectorView);
   m_DataNodeContextMenu->SetDataStorage(GetDataStorage());
   //m_DataNodeContextMenu->SetSurfaceDecimation(m_SurfaceDecimation);
 
    // connect objects
   connect(m_Controls.comboBoxRenderWindowSelection, QOverload<const QString&>::of(&QComboBox::currentIndexChanged), this, &QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged);
   connect(m_InspectorView, &QAbstractItemView::customContextMenuRequested, m_DataNodeContextMenu, &QmitkDataNodeContextMenu::OnContextMenuRequested);
 
   m_RenderWindowPart = GetRenderWindowPart();
   // also sets the controlled renderer
-  RenderWindowPartActivated(m_RenderWindowPart);
+  SetControlledRenderer();
 }
 
 void QmitkRenderWindowManagerView::SetControlledRenderer()
 {
-  const mitk::RenderingManager::RenderWindowVector allRegisteredRenderWindows = mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
-  mitk::BaseRenderer* baseRenderer = nullptr;
+  QHash<QString, QmitkRenderWindow*> renderWindows;
+  if (m_RenderWindowPart != nullptr)
+  {
+    renderWindows = m_RenderWindowPart->GetQmitkRenderWindows();
+  }
+
   mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer;
   QStringList rendererNames;
-  for (const auto& renderWindow : allRegisteredRenderWindows)
+  m_Controls.comboBoxRenderWindowSelection->clear();
+  mitk::BaseRenderer* baseRenderer = nullptr;
+  for (const auto& renderWindow : renderWindows.values())
   {
-    baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow);
+    baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow());
     if (nullptr != baseRenderer)
     {
       controlledRenderer.push_back(baseRenderer);
       rendererNames.append(baseRenderer->GetName());
     }
   }
 
   m_RenderWindowInspector->SetControlledRenderer(controlledRenderer);
-
-  m_Controls.comboBoxRenderWindowSelection->clear();
   rendererNames.sort();
   m_Controls.comboBoxRenderWindowSelection->addItems(rendererNames);
 }
 
 void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString& renderWindowId)
 {
   m_RenderWindowInspector->SetActiveRenderWindow(renderWindowId);
   mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(renderWindowId.toStdString());
   if (nullptr != selectedRenderer)
   {
     m_DataNodeContextMenu->SetBaseRenderer(selectedRenderer);
   }
 }
 
 QItemSelectionModel* QmitkRenderWindowManagerView::GetDataNodeSelectionModel() const
 {
   return m_InspectorView->selectionModel();
 }