diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h
index 6e30a38584..23af38d3c3 100644
--- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h
+++ b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h
@@ -1,71 +1,79 @@
 /*===================================================================
 
 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*> 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);
-
+    /**
+    * @brief Set renderer-specific properties to mark a data node as 'managed by the specific renderer'.
+    *        In order for a renderer to manage a data node, the 'fixedLayer' property has to be set for the given renderer.
+    *        Additionally, the 'visible' and the 'layer' property are set and allow to individually render a set of nodes
+    *        with a specific renderer.
+    *        The last two mentioned properties are set so that they initially have the same value as the corresponding
+    *        global property.
+    */
+    MITKRENDERWINDOWMANAGER_EXPORT void SetRenderWindowProperties(mitk::DataNode* dataNode, const BaseRenderer* renderer);
   } // namespace RenderWindowLayerUtilities
 } // namespace mitk
 
 #endif // MITKRENDERWINDOWLAYERUTILITIES_H
diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp
index 2ba1043c82..4ca3aa6af3 100644
--- a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp
+++ b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp
@@ -1,575 +1,567 @@
 /*===================================================================
 
 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 (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 (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);
-  }
+  RenderWindowLayerUtilities::SetRenderWindowProperties(dataNode, 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 (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 (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 (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 (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 (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 (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 (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 (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 (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/mitkRenderWindowLayerUtilities.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp
index b3fd2e8a12..fd34b0de43 100644
--- a/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp
+++ b/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp
@@ -1,68 +1,92 @@
 /*===================================================================
 
 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 "mitkRenderWindowLayerUtilities.h"
 
 // mitk core
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 mitk::RenderWindowLayerUtilities::LayerStack mitk::RenderWindowLayerUtilities::GetLayerStack(const DataStorage* dataStorage, const BaseRenderer* renderer, bool withBaseNode)
 {
   LayerStack stackedLayers;
   if (nullptr == dataStorage || nullptr == renderer)
   {
     // no nodes to stack or no renderer selected
     return stackedLayers;
   }
 
   int layer = -1;
   NodePredicateAnd::Pointer combinedNodePredicate = GetRenderWindowPredicate(renderer);
   DataStorage::SetOfObjects::ConstPointer filteredDataNodes = dataStorage->GetSubset(combinedNodePredicate);
   for (DataStorage::SetOfObjects::ConstIterator it = filteredDataNodes->Begin(); it != filteredDataNodes->End(); ++it)
   {
     DataNode::Pointer dataNode = it->Value();
     if (dataNode.IsNull())
     {
       continue;
     }
 
     bool layerFound = dataNode->GetIntProperty("layer", layer, renderer);
     if (layerFound)
     {
       if (BASE_LAYER_INDEX != layer|| withBaseNode)
       {
         // data node is not on the base layer or the base layer should be included anyway
         stackedLayers.insert(std::make_pair(layer, dataNode));
       }
     }
   }
   return stackedLayers;
 }
 
 mitk::NodePredicateAnd::Pointer mitk::RenderWindowLayerUtilities::GetRenderWindowPredicate(const BaseRenderer* renderer)
 {
   NodePredicateAnd::Pointer renderWindowPredicate = NodePredicateAnd::New();
 
   NodePredicateProperty::Pointer helperObject = NodePredicateProperty::New("helper object", BoolProperty::New(true));
   NodePredicateProperty::Pointer fixedLayer = NodePredicateProperty::New("fixedLayer", BoolProperty::New(true), renderer);
 
   renderWindowPredicate->AddPredicate(NodePredicateNot::New(helperObject));
   renderWindowPredicate->AddPredicate(fixedLayer);
 
   return renderWindowPredicate;
 }
+
+void mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(mitk::DataNode* dataNode, const BaseRenderer* renderer)
+{
+  dataNode->SetBoolProperty("fixedLayer", true, renderer);
+  // use visibility of existing renderer or common renderer
+  // common renderer is used if renderer-specific property does not exist
+  bool visible = false;
+  bool visibilityProperty = dataNode->GetVisibility(visible, renderer);
+  if (true == visibilityProperty)
+  {
+    // found a visibility property
+    dataNode->SetVisibility(visible, renderer);
+  }
+
+  // use layer of existing renderer or common renderer
+  // common renderer is used if renderer-specific property does not exist
+  int layer = -1;
+  bool layerProperty = dataNode->GetIntProperty("layer", layer, renderer);
+  if (true == layerProperty)
+  {
+    // found a layer property
+    dataNode->SetIntProperty("layer", layer, renderer);
+  }
+}